@batijs/cli 0.0.88 → 0.0.91

package/dist/index.js

@@ -600,7 +600,7 @@ Please report this issue to https://github.com/magne4000/bati`
 // package.json
 var package_default = {
   name: "@batijs/cli",
-  version: "0.0.88",
+  version: "0.0.91",
   type: "module",
   scripts: {
     prerelease: "rimraf ./dist",
@@ -622,12 +622,14 @@ var package_default = {
     esbuild: "^0.19.4",
     execa: "^8.0.1",
     rimraf: "^5.0.5",
+    sift: "^17.0.1",
     tsup: "^7.2.0",
     typescript: "^5.2.2",
     vite: "^4.4.11"
   },
   dependencies: {
-    "@batijs/core": "workspace:*"
+    "@batijs/core": "workspace:*",
+    "@batijs/features": "workspace:*"
   },
   bin: "./dist/index.js",
   exports: {
@@ -639,8 +641,9 @@ var package_default = {
 };
 
 // index.ts
-import { flags as coreFlags, withIcon } from "@batijs/core";
-import { execRules } from "@batijs/core/rules";
+import { withIcon } from "@batijs/core";
+import { features, flags as coreFlags } from "@batijs/features";
+import { execRules } from "@batijs/features/rules";
 import { existsSync as existsSync2 } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join, parse } from "path";
@@ -762,7 +765,7 @@ var {
 } = createColors();
 
 // rules.ts
-import { RulesMessage } from "@batijs/core/rules";
+import { RulesMessage } from "@batijs/features/rules";
 function error(value) {
   return {
     type: "error",
@@ -784,6 +787,781 @@ var rulesMessages = {
   [RulesMessage.INFO_HATTIP]: info(`${inverse(bold("HatTip"))} is an experimental project`)
 };
 
+// ../../node_modules/.pnpm/sift@17.0.1/node_modules/sift/es5m/index.js
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2)
+      if (Object.prototype.hasOwnProperty.call(b2, p))
+        d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+var typeChecker = function(type) {
+  var typeString = "[object " + type + "]";
+  return function(value) {
+    return getClassName(value) === typeString;
+  };
+};
+var getClassName = function(value) {
+  return Object.prototype.toString.call(value);
+};
+var comparable = function(value) {
+  if (value instanceof Date) {
+    return value.getTime();
+  } else if (isArray(value)) {
+    return value.map(comparable);
+  } else if (value && typeof value.toJSON === "function") {
+    return value.toJSON();
+  }
+  return value;
+};
+var coercePotentiallyNull = function(value) {
+  return value == null ? null : value;
+};
+var isArray = typeChecker("Array");
+var isObject = typeChecker("Object");
+var isFunction = typeChecker("Function");
+var isVanillaObject = function(value) {
+  return value && (value.constructor === Object || value.constructor === Array || value.constructor.toString() === "function Object() { [native code] }" || value.constructor.toString() === "function Array() { [native code] }") && !value.toJSON;
+};
+var equals = function(a, b) {
+  if (a == null && a == b) {
+    return true;
+  }
+  if (a === b) {
+    return true;
+  }
+  if (Object.prototype.toString.call(a) !== Object.prototype.toString.call(b)) {
+    return false;
+  }
+  if (isArray(a)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (var i = 0, length_1 = a.length; i < length_1; i++) {
+      if (!equals(a[i], b[i]))
+        return false;
+    }
+    return true;
+  } else if (isObject(a)) {
+    if (Object.keys(a).length !== Object.keys(b).length) {
+      return false;
+    }
+    for (var key in a) {
+      if (!equals(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+};
+var walkKeyPathValues = function(item, keyPath, next, depth, key, owner) {
+  var currentKey = keyPath[depth];
+  if (isArray(item) && isNaN(Number(currentKey))) {
+    for (var i = 0, length_1 = item.length; i < length_1; i++) {
+      if (!walkKeyPathValues(item[i], keyPath, next, depth, i, item)) {
+        return false;
+      }
+    }
+  }
+  if (depth === keyPath.length || item == null) {
+    return next(item, key, owner, depth === 0);
+  }
+  return walkKeyPathValues(item[currentKey], keyPath, next, depth + 1, currentKey, item);
+};
+var BaseOperation = (
+  /** @class */
+  function() {
+    function BaseOperation2(params, owneryQuery, options, name) {
+      this.params = params;
+      this.owneryQuery = owneryQuery;
+      this.options = options;
+      this.name = name;
+      this.init();
+    }
+    BaseOperation2.prototype.init = function() {
+    };
+    BaseOperation2.prototype.reset = function() {
+      this.done = false;
+      this.keep = false;
+    };
+    return BaseOperation2;
+  }()
+);
+var GroupOperation = (
+  /** @class */
+  function(_super) {
+    __extends(GroupOperation2, _super);
+    function GroupOperation2(params, owneryQuery, options, children) {
+      var _this = _super.call(this, params, owneryQuery, options) || this;
+      _this.children = children;
+      return _this;
+    }
+    GroupOperation2.prototype.reset = function() {
+      this.keep = false;
+      this.done = false;
+      for (var i = 0, length_2 = this.children.length; i < length_2; i++) {
+        this.children[i].reset();
+      }
+    };
+    GroupOperation2.prototype.childrenNext = function(item, key, owner, root) {
+      var done = true;
+      var keep = true;
+      for (var i = 0, length_3 = this.children.length; i < length_3; i++) {
+        var childOperation = this.children[i];
+        if (!childOperation.done) {
+          childOperation.next(item, key, owner, root);
+        }
+        if (!childOperation.keep) {
+          keep = false;
+        }
+        if (childOperation.done) {
+          if (!childOperation.keep) {
+            break;
+          }
+        } else {
+          done = false;
+        }
+      }
+      this.done = done;
+      this.keep = keep;
+    };
+    return GroupOperation2;
+  }(BaseOperation)
+);
+var NamedGroupOperation = (
+  /** @class */
+  function(_super) {
+    __extends(NamedGroupOperation2, _super);
+    function NamedGroupOperation2(params, owneryQuery, options, children, name) {
+      var _this = _super.call(this, params, owneryQuery, options, children) || this;
+      _this.name = name;
+      return _this;
+    }
+    return NamedGroupOperation2;
+  }(GroupOperation)
+);
+var QueryOperation = (
+  /** @class */
+  function(_super) {
+    __extends(QueryOperation2, _super);
+    function QueryOperation2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.propop = true;
+      return _this;
+    }
+    QueryOperation2.prototype.next = function(item, key, parent, root) {
+      this.childrenNext(item, key, parent, root);
+    };
+    return QueryOperation2;
+  }(GroupOperation)
+);
+var NestedOperation = (
+  /** @class */
+  function(_super) {
+    __extends(NestedOperation2, _super);
+    function NestedOperation2(keyPath, params, owneryQuery, options, children) {
+      var _this = _super.call(this, params, owneryQuery, options, children) || this;
+      _this.keyPath = keyPath;
+      _this.propop = true;
+      _this._nextNestedValue = function(value, key, owner, root) {
+        _this.childrenNext(value, key, owner, root);
+        return !_this.done;
+      };
+      return _this;
+    }
+    NestedOperation2.prototype.next = function(item, key, parent) {
+      walkKeyPathValues(item, this.keyPath, this._nextNestedValue, 0, key, parent);
+    };
+    return NestedOperation2;
+  }(GroupOperation)
+);
+var createTester = function(a, compare) {
+  if (a instanceof Function) {
+    return a;
+  }
+  if (a instanceof RegExp) {
+    return function(b) {
+      var result = typeof b === "string" && a.test(b);
+      a.lastIndex = 0;
+      return result;
+    };
+  }
+  var comparableA = comparable(a);
+  return function(b) {
+    return compare(comparableA, comparable(b));
+  };
+};
+var EqualsOperation = (
+  /** @class */
+  function(_super) {
+    __extends(EqualsOperation2, _super);
+    function EqualsOperation2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.propop = true;
+      return _this;
+    }
+    EqualsOperation2.prototype.init = function() {
+      this._test = createTester(this.params, this.options.compare);
+    };
+    EqualsOperation2.prototype.next = function(item, key, parent) {
+      if (!Array.isArray(parent) || parent.hasOwnProperty(key)) {
+        if (this._test(item, key, parent)) {
+          this.done = true;
+          this.keep = true;
+        }
+      }
+    };
+    return EqualsOperation2;
+  }(BaseOperation)
+);
+var numericalOperationCreator = function(createNumericalOperation) {
+  return function(params, owneryQuery, options, name) {
+    return createNumericalOperation(params, owneryQuery, options, name);
+  };
+};
+var numericalOperation = function(createTester2) {
+  return numericalOperationCreator(function(params, owneryQuery, options, name) {
+    var typeofParams = typeof comparable(params);
+    var test = createTester2(params);
+    return new EqualsOperation(function(b) {
+      var actualValue = coercePotentiallyNull(b);
+      return typeof comparable(actualValue) === typeofParams && test(actualValue);
+    }, owneryQuery, options, name);
+  });
+};
+var createNamedOperation = function(name, params, parentQuery, options) {
+  var operationCreator = options.operations[name];
+  if (!operationCreator) {
+    throwUnsupportedOperation(name);
+  }
+  return operationCreator(params, parentQuery, options, name);
+};
+var throwUnsupportedOperation = function(name) {
+  throw new Error("Unsupported operation: " + name);
+};
+var containsOperation = function(query, options) {
+  for (var key in query) {
+    if (options.operations.hasOwnProperty(key) || key.charAt(0) === "$")
+      return true;
+  }
+  return false;
+};
+var createNestedOperation = function(keyPath, nestedQuery, parentKey, owneryQuery, options) {
+  if (containsOperation(nestedQuery, options)) {
+    var _a = createQueryOperations(nestedQuery, parentKey, options), selfOperations = _a[0], nestedOperations = _a[1];
+    if (nestedOperations.length) {
+      throw new Error("Property queries must contain only operations, or exact objects.");
+    }
+    return new NestedOperation(keyPath, nestedQuery, owneryQuery, options, selfOperations);
+  }
+  return new NestedOperation(keyPath, nestedQuery, owneryQuery, options, [
+    new EqualsOperation(nestedQuery, owneryQuery, options)
+  ]);
+};
+var createQueryOperation = function(query, owneryQuery, _a) {
+  if (owneryQuery === void 0) {
+    owneryQuery = null;
+  }
+  var _b = _a === void 0 ? {} : _a, compare = _b.compare, operations = _b.operations;
+  var options = {
+    compare: compare || equals,
+    operations: Object.assign({}, operations || {})
+  };
+  var _c = createQueryOperations(query, null, options), selfOperations = _c[0], nestedOperations = _c[1];
+  var ops = [];
+  if (selfOperations.length) {
+    ops.push(new NestedOperation([], query, owneryQuery, options, selfOperations));
+  }
+  ops.push.apply(ops, nestedOperations);
+  if (ops.length === 1) {
+    return ops[0];
+  }
+  return new QueryOperation(query, owneryQuery, options, ops);
+};
+var createQueryOperations = function(query, parentKey, options) {
+  var selfOperations = [];
+  var nestedOperations = [];
+  if (!isVanillaObject(query)) {
+    selfOperations.push(new EqualsOperation(query, query, options));
+    return [selfOperations, nestedOperations];
+  }
+  for (var key in query) {
+    if (options.operations.hasOwnProperty(key)) {
+      var op = createNamedOperation(key, query[key], query, options);
+      if (op) {
+        if (!op.propop && parentKey && !options.operations[parentKey]) {
+          throw new Error("Malformed query. " + key + " cannot be matched against property.");
+        }
+      }
+      if (op != null) {
+        selfOperations.push(op);
+      }
+    } else if (key.charAt(0) === "$") {
+      throwUnsupportedOperation(key);
+    } else {
+      nestedOperations.push(createNestedOperation(key.split("."), query[key], key, query, options));
+    }
+  }
+  return [selfOperations, nestedOperations];
+};
+var createOperationTester = function(operation) {
+  return function(item, key, owner) {
+    operation.reset();
+    operation.next(item, key, owner);
+    return operation.keep;
+  };
+};
+var $Ne = (
+  /** @class */
+  function(_super) {
+    __extends($Ne2, _super);
+    function $Ne2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.propop = true;
+      return _this;
+    }
+    $Ne2.prototype.init = function() {
+      this._test = createTester(this.params, this.options.compare);
+    };
+    $Ne2.prototype.reset = function() {
+      _super.prototype.reset.call(this);
+      this.keep = true;
+    };
+    $Ne2.prototype.next = function(item) {
+      if (this._test(item)) {
+        this.done = true;
+        this.keep = false;
+      }
+    };
+    return $Ne2;
+  }(BaseOperation)
+);
+var $ElemMatch = (
+  /** @class */
+  function(_super) {
+    __extends($ElemMatch2, _super);
+    function $ElemMatch2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.propop = true;
+      return _this;
+    }
+    $ElemMatch2.prototype.init = function() {
+      if (!this.params || typeof this.params !== "object") {
+        throw new Error("Malformed query. $elemMatch must by an object.");
+      }
+      this._queryOperation = createQueryOperation(this.params, this.owneryQuery, this.options);
+    };
+    $ElemMatch2.prototype.reset = function() {
+      _super.prototype.reset.call(this);
+      this._queryOperation.reset();
+    };
+    $ElemMatch2.prototype.next = function(item) {
+      if (isArray(item)) {
+        for (var i = 0, length_1 = item.length; i < length_1; i++) {
+          this._queryOperation.reset();
+          var child = item[i];
+          this._queryOperation.next(child, i, item, false);
+          this.keep = this.keep || this._queryOperation.keep;
+        }
+        this.done = true;
+      } else {
+        this.done = false;
+        this.keep = false;
+      }
+    };
+    return $ElemMatch2;
+  }(BaseOperation)
+);
+var $Not = (
+  /** @class */
+  function(_super) {
+    __extends($Not2, _super);
+    function $Not2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.propop = true;
+      return _this;
+    }
+    $Not2.prototype.init = function() {
+      this._queryOperation = createQueryOperation(this.params, this.owneryQuery, this.options);
+    };
+    $Not2.prototype.reset = function() {
+      _super.prototype.reset.call(this);
+      this._queryOperation.reset();
+    };
+    $Not2.prototype.next = function(item, key, owner, root) {
+      this._queryOperation.next(item, key, owner, root);
+      this.done = this._queryOperation.done;
+      this.keep = !this._queryOperation.keep;
+    };
+    return $Not2;
+  }(BaseOperation)
+);
+var $Size = (
+  /** @class */
+  function(_super) {
+    __extends($Size2, _super);
+    function $Size2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.propop = true;
+      return _this;
+    }
+    $Size2.prototype.init = function() {
+    };
+    $Size2.prototype.next = function(item) {
+      if (isArray(item) && item.length === this.params) {
+        this.done = true;
+        this.keep = true;
+      }
+    };
+    return $Size2;
+  }(BaseOperation)
+);
+var assertGroupNotEmpty = function(values) {
+  if (values.length === 0) {
+    throw new Error("$and/$or/$nor must be a nonempty array");
+  }
+};
+var $Or = (
+  /** @class */
+  function(_super) {
+    __extends($Or2, _super);
+    function $Or2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.propop = false;
+      return _this;
+    }
+    $Or2.prototype.init = function() {
+      var _this = this;
+      assertGroupNotEmpty(this.params);
+      this._ops = this.params.map(function(op) {
+        return createQueryOperation(op, null, _this.options);
+      });
+    };
+    $Or2.prototype.reset = function() {
+      this.done = false;
+      this.keep = false;
+      for (var i = 0, length_2 = this._ops.length; i < length_2; i++) {
+        this._ops[i].reset();
+      }
+    };
+    $Or2.prototype.next = function(item, key, owner) {
+      var done = false;
+      var success = false;
+      for (var i = 0, length_3 = this._ops.length; i < length_3; i++) {
+        var op = this._ops[i];
+        op.next(item, key, owner);
+        if (op.keep) {
+          done = true;
+          success = op.keep;
+          break;
+        }
+      }
+      this.keep = success;
+      this.done = done;
+    };
+    return $Or2;
+  }(BaseOperation)
+);
+var $Nor = (
+  /** @class */
+  function(_super) {
+    __extends($Nor2, _super);
+    function $Nor2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.propop = false;
+      return _this;
+    }
+    $Nor2.prototype.next = function(item, key, owner) {
+      _super.prototype.next.call(this, item, key, owner);
+      this.keep = !this.keep;
+    };
+    return $Nor2;
+  }($Or)
+);
+var $In = (
+  /** @class */
+  function(_super) {
+    __extends($In2, _super);
+    function $In2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.propop = true;
+      return _this;
+    }
+    $In2.prototype.init = function() {
+      var _this = this;
+      this._testers = this.params.map(function(value) {
+        if (containsOperation(value, _this.options)) {
+          throw new Error("cannot nest $ under " + _this.name.toLowerCase());
+        }
+        return createTester(value, _this.options.compare);
+      });
+    };
+    $In2.prototype.next = function(item, key, owner) {
+      var done = false;
+      var success = false;
+      for (var i = 0, length_4 = this._testers.length; i < length_4; i++) {
+        var test = this._testers[i];
+        if (test(item)) {
+          done = true;
+          success = true;
+          break;
+        }
+      }
+      this.keep = success;
+      this.done = done;
+    };
+    return $In2;
+  }(BaseOperation)
+);
+var $Nin = (
+  /** @class */
+  function(_super) {
+    __extends($Nin2, _super);
+    function $Nin2(params, ownerQuery, options, name) {
+      var _this = _super.call(this, params, ownerQuery, options, name) || this;
+      _this.propop = true;
+      _this._in = new $In(params, ownerQuery, options, name);
+      return _this;
+    }
+    $Nin2.prototype.next = function(item, key, owner, root) {
+      this._in.next(item, key, owner);
+      if (isArray(owner) && !root) {
+        if (this._in.keep) {
+          this.keep = false;
+          this.done = true;
+        } else if (key == owner.length - 1) {
+          this.keep = true;
+          this.done = true;
+        }
+      } else {
+        this.keep = !this._in.keep;
+        this.done = true;
+      }
+    };
+    $Nin2.prototype.reset = function() {
+      _super.prototype.reset.call(this);
+      this._in.reset();
+    };
+    return $Nin2;
+  }(BaseOperation)
+);
+var $Exists = (
+  /** @class */
+  function(_super) {
+    __extends($Exists2, _super);
+    function $Exists2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.propop = true;
+      return _this;
+    }
+    $Exists2.prototype.next = function(item, key, owner) {
+      if (owner.hasOwnProperty(key) === this.params) {
+        this.done = true;
+        this.keep = true;
+      }
+    };
+    return $Exists2;
+  }(BaseOperation)
+);
+var $And = (
+  /** @class */
+  function(_super) {
+    __extends($And2, _super);
+    function $And2(params, owneryQuery, options, name) {
+      var _this = _super.call(this, params, owneryQuery, options, params.map(function(query) {
+        return createQueryOperation(query, owneryQuery, options);
+      }), name) || this;
+      _this.propop = false;
+      assertGroupNotEmpty(params);
+      return _this;
+    }
+    $And2.prototype.next = function(item, key, owner, root) {
+      this.childrenNext(item, key, owner, root);
+    };
+    return $And2;
+  }(NamedGroupOperation)
+);
+var $All = (
+  /** @class */
+  function(_super) {
+    __extends($All2, _super);
+    function $All2(params, owneryQuery, options, name) {
+      var _this = _super.call(this, params, owneryQuery, options, params.map(function(query) {
+        return createQueryOperation(query, owneryQuery, options);
+      }), name) || this;
+      _this.propop = true;
+      return _this;
+    }
+    $All2.prototype.next = function(item, key, owner, root) {
+      this.childrenNext(item, key, owner, root);
+    };
+    return $All2;
+  }(NamedGroupOperation)
+);
+var $eq = function(params, owneryQuery, options) {
+  return new EqualsOperation(params, owneryQuery, options);
+};
+var $ne = function(params, owneryQuery, options, name) {
+  return new $Ne(params, owneryQuery, options, name);
+};
+var $or = function(params, owneryQuery, options, name) {
+  return new $Or(params, owneryQuery, options, name);
+};
+var $nor = function(params, owneryQuery, options, name) {
+  return new $Nor(params, owneryQuery, options, name);
+};
+var $elemMatch = function(params, owneryQuery, options, name) {
+  return new $ElemMatch(params, owneryQuery, options, name);
+};
+var $nin = function(params, owneryQuery, options, name) {
+  return new $Nin(params, owneryQuery, options, name);
+};
+var $in = function(params, owneryQuery, options, name) {
+  return new $In(params, owneryQuery, options, name);
+};
+var $lt = numericalOperation(function(params) {
+  return function(b) {
+    return b != null && b < params;
+  };
+});
+var $lte = numericalOperation(function(params) {
+  return function(b) {
+    return b === params || b <= params;
+  };
+});
+var $gt = numericalOperation(function(params) {
+  return function(b) {
+    return b != null && b > params;
+  };
+});
+var $gte = numericalOperation(function(params) {
+  return function(b) {
+    return b === params || b >= params;
+  };
+});
+var $mod = function(_a, owneryQuery, options) {
+  var mod = _a[0], equalsValue = _a[1];
+  return new EqualsOperation(function(b) {
+    return comparable(b) % mod === equalsValue;
+  }, owneryQuery, options);
+};
+var $exists = function(params, owneryQuery, options, name) {
+  return new $Exists(params, owneryQuery, options, name);
+};
+var $regex = function(pattern, owneryQuery, options) {
+  return new EqualsOperation(new RegExp(pattern, owneryQuery.$options), owneryQuery, options);
+};
+var $not = function(params, owneryQuery, options, name) {
+  return new $Not(params, owneryQuery, options, name);
+};
+var typeAliases = {
+  number: function(v) {
+    return typeof v === "number";
+  },
+  string: function(v) {
+    return typeof v === "string";
+  },
+  bool: function(v) {
+    return typeof v === "boolean";
+  },
+  array: function(v) {
+    return Array.isArray(v);
+  },
+  null: function(v) {
+    return v === null;
+  },
+  timestamp: function(v) {
+    return v instanceof Date;
+  }
+};
+var $type = function(clazz, owneryQuery, options) {
+  return new EqualsOperation(function(b) {
+    if (typeof clazz === "string") {
+      if (!typeAliases[clazz]) {
+        throw new Error("Type alias does not exist");
+      }
+      return typeAliases[clazz](b);
+    }
+    return b != null ? b instanceof clazz || b.constructor === clazz : false;
+  }, owneryQuery, options);
+};
+var $and = function(params, ownerQuery, options, name) {
+  return new $And(params, ownerQuery, options, name);
+};
+var $all = function(params, ownerQuery, options, name) {
+  return new $All(params, ownerQuery, options, name);
+};
+var $size = function(params, ownerQuery, options) {
+  return new $Size(params, ownerQuery, options, "$size");
+};
+var $options = function() {
+  return null;
+};
+var $where = function(params, ownerQuery, options) {
+  var test;
+  if (isFunction(params)) {
+    test = params;
+  } else if (!process.env.CSP_ENABLED) {
+    test = new Function("obj", "return " + params);
+  } else {
+    throw new Error('In CSP mode, sift does not support strings in "$where" condition');
+  }
+  return new EqualsOperation(function(b) {
+    return test.bind(b)(b);
+  }, ownerQuery, options);
+};
+var defaultOperations = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  $Size,
+  $eq,
+  $ne,
+  $or,
+  $nor,
+  $elemMatch,
+  $nin,
+  $in,
+  $lt,
+  $lte,
+  $gt,
+  $gte,
+  $mod,
+  $exists,
+  $regex,
+  $not,
+  $type,
+  $and,
+  $all,
+  $size,
+  $options,
+  $where
+});
+var createDefaultQueryOperation = function(query, ownerQuery, _a) {
+  var _b = _a === void 0 ? {} : _a, compare = _b.compare, operations = _b.operations;
+  return createQueryOperation(query, ownerQuery, {
+    compare,
+    operations: Object.assign({}, defaultOperations, operations || {})
+  });
+};
+var createDefaultQueryTester = function(query, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var op = createDefaultQueryOperation(query, null, options);
+  return createOperationTester(op);
+};
+
 // index.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
@@ -810,29 +1588,29 @@ function toArg(flag, description) {
     }
   };
 }
-function findDescription(key, boilerplates) {
-  const bl = boilerplates.find((b) => b.config.flag === key);
-  if (!bl)
+function findDescription(key) {
+  const feat = features.find((f) => f.flag === key);
+  if (!feat)
     return;
-  if (bl.description) {
-    return bl.description;
-  } else if (bl.config.name && bl.config.homepage) {
-    return `Include ${bl.config.name} - ${bl.config.homepage}`;
-  } else if (bl.config.name) {
-    return `Include ${bl.config.name}`;
+  if (feat.description) {
+    return feat.description;
+  } else if (feat.label && feat.url) {
+    return `Include ${feat.label} - ${feat.url}`;
+  } else if (feat.label) {
+    return `Include ${feat.label}`;
   }
 }
-function printOK(dist, flags, boilerplates) {
+function printOK(dist, flags) {
   const arrow0 = withIcon("\u2192", blueBright);
   const list3 = withIcon("-", void 0, 3);
   const cmd3 = withIcon("$", gray, 3);
   console.log(bold(`${green("\u2713")} Project created at ${cyan(dist)} with:`));
-  console.log(list3(green("Typescript")));
+  console.log(list3(green("Vike")));
   for (const key of flags) {
-    const bl = boilerplates.find((b) => b.config.flag === key);
-    if (!bl || !bl.config.name)
+    const feature = features.find((f) => f.flag === key);
+    if (!feature || !feature.label)
       continue;
-    console.log(list3(green(bl.config.name)));
+    console.log(list3(green(feature.label)));
   }
   console.log("\n" + bold(arrow0("Next steps:")));
   console.log(cmd3(`cd ${dist}`));
@@ -843,7 +1621,8 @@ var defaultDef = {
   project: {
     type: "positional",
     description: "Project directory",
-    required: true
+    required: false,
+    default: "my-app"
   }
 };
 function yn(value, default_) {
@@ -890,8 +1669,7 @@ async function checkArguments(args) {
   }
 }
 function checkRules(flags) {
-  const flagsWithNs = flags.map((f) => coreFlags.get(f));
-  const potentialRulesMessages = execRules(flagsWithNs, rulesMessages);
+  const potentialRulesMessages = execRules(flags, rulesMessages);
   const infos = potentialRulesMessages.filter((m) => m.type === "info");
   const warnings = potentialRulesMessages.filter((m) => m.type === "warning");
   const errors = potentialRulesMessages.filter((m) => m.type === "error");
@@ -936,11 +1714,8 @@ async function retrieveHooks(hooks) {
   return map;
 }
 function testFlags(flags, bl) {
-  if (bl.config.flag) {
-    return flags.includes(bl.config.flag);
-  }
-  if (Array.isArray(bl.config.includeIf)) {
-    return bl.config.includeIf.every((f) => flags.includes(f));
+  if (bl.config.if) {
+    return createDefaultQueryTester(bl.config.if)(flags.map((f) => ({ flag: f })));
   }
   return true;
 }
@@ -956,13 +1731,12 @@ async function run() {
     args: Object.assign(
       {},
       defaultDef,
-      ...Array.from(coreFlags.keys()).map((k) => toArg(k, findDescription(k, boilerplates)))
+      ...coreFlags.map((k) => toArg(k, findDescription(k)))
     ),
     async run({ args }) {
       await checkArguments(args);
       const sources = [];
       const hooks = [];
-      const features = [];
       const flags = Object.entries(args).filter(([, val]) => val === true).map(([key]) => key);
       checkRules(flags);
       boilerplates.sort((b1, b2) => {
@@ -986,12 +1760,9 @@ async function run() {
           }
         }
       }
-      for (const flag of flags) {
-        features.push(coreFlags.get(flag));
-      }
       const hooksMap = await retrieveHooks(hooks);
       const meta = {
-        BATI_MODULES: features
+        BATI_MODULES: flags
       };
       await main(
         {
@@ -1000,7 +1771,7 @@ async function run() {
         },
         meta
       );
-      printOK(args.project, flags, boilerplates);
+      printOK(args.project, flags);
       for (const oncli of hooksMap.get("cli") ?? []) {
         await oncli(meta);
       }
@@ -1017,3 +1788,21 @@ run().then(() => {
 export {
   yn as default
 };
+/*! Bundled license information:
+
+sift/es5m/index.js:
+  (*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+  
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+  
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** *)
+*/