@nexo-labs/payload-taxonomies 0.8.5 → 0.8.6

package/dist/index.js

@@ -1,1015 +1,4 @@
-// src/taxonomy.ts
-var COLLECTION_SLUG_TAXONOMY = "taxonomy";
-var taxonomiesCollection = (config) => ({
-  ...config,
-  slug: COLLECTION_SLUG_TAXONOMY,
-  labels: {
-    singular: "Taxonomia",
-    plural: "Taxonomias"
-  },
-  admin: {
-    useAsTitle: "singular_name",
-    group: "Contenido"
-  },
-  fields: [
-    {
-      name: "singular_name",
-      label: "Nombre singular",
-      type: "text",
-      localized: true,
-      required: true
-    },
-    {
-      name: "plural_name",
-      label: "Nombre plural",
-      type: "text",
-      localized: true,
-      required: false
-    },
-    {
-      name: "payload",
-      label: "Payload Adicional",
-      type: "json",
-      required: false
-    },
-    ...config.fields ?? []
-  ]
-});
-
-// ../../node_modules/.pnpm/jsep@1.4.0/node_modules/jsep/dist/jsep.js
-var Hooks = class {
-  /**
-   * @callback HookCallback
-   * @this {*|Jsep} this
-   * @param {Jsep} env
-   * @returns: void
-   */
-  /**
-   * Adds the given callback to the list of callbacks for the given hook.
-   *
-   * The callback will be invoked when the hook it is registered for is run.
-   *
-   * One callback function can be registered to multiple hooks and the same hook multiple times.
-   *
-   * @param {string|object} name The name of the hook, or an object of callbacks keyed by name
-   * @param {HookCallback|boolean} callback The callback function which is given environment variables.
-   * @param {?boolean} [first=false] Will add the hook to the top of the list (defaults to the bottom)
-   * @public
-   */
-  add(name, callback, first) {
-    if (typeof arguments[0] != "string") {
-      for (let name2 in arguments[0]) {
-        this.add(name2, arguments[0][name2], arguments[1]);
-      }
-    } else {
-      (Array.isArray(name) ? name : [name]).forEach(function(name2) {
-        this[name2] = this[name2] || [];
-        if (callback) {
-          this[name2][first ? "unshift" : "push"](callback);
-        }
-      }, this);
-    }
-  }
-  /**
-   * Runs a hook invoking all registered callbacks with the given environment variables.
-   *
-   * Callbacks will be invoked synchronously and in the order in which they were registered.
-   *
-   * @param {string} name The name of the hook.
-   * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
-   * @public
-   */
-  run(name, env) {
-    this[name] = this[name] || [];
-    this[name].forEach(function(callback) {
-      callback.call(env && env.context ? env.context : env, env);
-    });
-  }
-};
-var Plugins = class {
-  constructor(jsep2) {
-    this.jsep = jsep2;
-    this.registered = {};
-  }
-  /**
-   * @callback PluginSetup
-   * @this {Jsep} jsep
-   * @returns: void
-   */
-  /**
-   * Adds the given plugin(s) to the registry
-   *
-   * @param {object} plugins
-   * @param {string} plugins.name The name of the plugin
-   * @param {PluginSetup} plugins.init The init function
-   * @public
-   */
-  register(...plugins) {
-    plugins.forEach((plugin) => {
-      if (typeof plugin !== "object" || !plugin.name || !plugin.init) {
-        throw new Error("Invalid JSEP plugin format");
-      }
-      if (this.registered[plugin.name]) {
-        return;
-      }
-      plugin.init(this.jsep);
-      this.registered[plugin.name] = plugin;
-    });
-  }
-};
-var Jsep = class _Jsep {
-  /**
-   * @returns {string}
-   */
-  static get version() {
-    return "1.4.0";
-  }
-  /**
-   * @returns {string}
-   */
-  static toString() {
-    return "JavaScript Expression Parser (JSEP) v" + _Jsep.version;
-  }
-  // ==================== CONFIG ================================
-  /**
-   * @method addUnaryOp
-   * @param {string} op_name The name of the unary op to add
-   * @returns {Jsep}
-   */
-  static addUnaryOp(op_name) {
-    _Jsep.max_unop_len = Math.max(op_name.length, _Jsep.max_unop_len);
-    _Jsep.unary_ops[op_name] = 1;
-    return _Jsep;
-  }
-  /**
-   * @method jsep.addBinaryOp
-   * @param {string} op_name The name of the binary op to add
-   * @param {number} precedence The precedence of the binary op (can be a float). Higher number = higher precedence
-   * @param {boolean} [isRightAssociative=false] whether operator is right-associative
-   * @returns {Jsep}
-   */
-  static addBinaryOp(op_name, precedence, isRightAssociative) {
-    _Jsep.max_binop_len = Math.max(op_name.length, _Jsep.max_binop_len);
-    _Jsep.binary_ops[op_name] = precedence;
-    if (isRightAssociative) {
-      _Jsep.right_associative.add(op_name);
-    } else {
-      _Jsep.right_associative.delete(op_name);
-    }
-    return _Jsep;
-  }
-  /**
-   * @method addIdentifierChar
-   * @param {string} char The additional character to treat as a valid part of an identifier
-   * @returns {Jsep}
-   */
-  static addIdentifierChar(char) {
-    _Jsep.additional_identifier_chars.add(char);
-    return _Jsep;
-  }
-  /**
-   * @method addLiteral
-   * @param {string} literal_name The name of the literal to add
-   * @param {*} literal_value The value of the literal
-   * @returns {Jsep}
-   */
-  static addLiteral(literal_name, literal_value) {
-    _Jsep.literals[literal_name] = literal_value;
-    return _Jsep;
-  }
-  /**
-   * @method removeUnaryOp
-   * @param {string} op_name The name of the unary op to remove
-   * @returns {Jsep}
-   */
-  static removeUnaryOp(op_name) {
-    delete _Jsep.unary_ops[op_name];
-    if (op_name.length === _Jsep.max_unop_len) {
-      _Jsep.max_unop_len = _Jsep.getMaxKeyLen(_Jsep.unary_ops);
-    }
-    return _Jsep;
-  }
-  /**
-   * @method removeAllUnaryOps
-   * @returns {Jsep}
-   */
-  static removeAllUnaryOps() {
-    _Jsep.unary_ops = {};
-    _Jsep.max_unop_len = 0;
-    return _Jsep;
-  }
-  /**
-   * @method removeIdentifierChar
-   * @param {string} char The additional character to stop treating as a valid part of an identifier
-   * @returns {Jsep}
-   */
-  static removeIdentifierChar(char) {
-    _Jsep.additional_identifier_chars.delete(char);
-    return _Jsep;
-  }
-  /**
-   * @method removeBinaryOp
-   * @param {string} op_name The name of the binary op to remove
-   * @returns {Jsep}
-   */
-  static removeBinaryOp(op_name) {
-    delete _Jsep.binary_ops[op_name];
-    if (op_name.length === _Jsep.max_binop_len) {
-      _Jsep.max_binop_len = _Jsep.getMaxKeyLen(_Jsep.binary_ops);
-    }
-    _Jsep.right_associative.delete(op_name);
-    return _Jsep;
-  }
-  /**
-   * @method removeAllBinaryOps
-   * @returns {Jsep}
-   */
-  static removeAllBinaryOps() {
-    _Jsep.binary_ops = {};
-    _Jsep.max_binop_len = 0;
-    return _Jsep;
-  }
-  /**
-   * @method removeLiteral
-   * @param {string} literal_name The name of the literal to remove
-   * @returns {Jsep}
-   */
-  static removeLiteral(literal_name) {
-    delete _Jsep.literals[literal_name];
-    return _Jsep;
-  }
-  /**
-   * @method removeAllLiterals
-   * @returns {Jsep}
-   */
-  static removeAllLiterals() {
-    _Jsep.literals = {};
-    return _Jsep;
-  }
-  // ==================== END CONFIG ============================
-  /**
-   * @returns {string}
-   */
-  get char() {
-    return this.expr.charAt(this.index);
-  }
-  /**
-   * @returns {number}
-   */
-  get code() {
-    return this.expr.charCodeAt(this.index);
-  }
-  /**
-   * @param {string} expr a string with the passed in express
-   * @returns Jsep
-   */
-  constructor(expr) {
-    this.expr = expr;
-    this.index = 0;
-  }
-  /**
-   * static top-level parser
-   * @returns {jsep.Expression}
-   */
-  static parse(expr) {
-    return new _Jsep(expr).parse();
-  }
-  /**
-   * Get the longest key length of any object
-   * @param {object} obj
-   * @returns {number}
-   */
-  static getMaxKeyLen(obj) {
-    return Math.max(0, ...Object.keys(obj).map((k) => k.length));
-  }
-  /**
-   * `ch` is a character code in the next three functions
-   * @param {number} ch
-   * @returns {boolean}
-   */
-  static isDecimalDigit(ch) {
-    return ch >= 48 && ch <= 57;
-  }
-  /**
-   * Returns the precedence of a binary operator or `0` if it isn't a binary operator. Can be float.
-   * @param {string} op_val
-   * @returns {number}
-   */
-  static binaryPrecedence(op_val) {
-    return _Jsep.binary_ops[op_val] || 0;
-  }
-  /**
-   * Looks for start of identifier
-   * @param {number} ch
-   * @returns {boolean}
-   */
-  static isIdentifierStart(ch) {
-    return ch >= 65 && ch <= 90 || // A...Z
-    ch >= 97 && ch <= 122 || // a...z
-    ch >= 128 && !_Jsep.binary_ops[String.fromCharCode(ch)] || // any non-ASCII that is not an operator
-    _Jsep.additional_identifier_chars.has(String.fromCharCode(ch));
-  }
-  /**
-   * @param {number} ch
-   * @returns {boolean}
-   */
-  static isIdentifierPart(ch) {
-    return _Jsep.isIdentifierStart(ch) || _Jsep.isDecimalDigit(ch);
-  }
-  /**
-   * throw error at index of the expression
-   * @param {string} message
-   * @throws
-   */
-  throwError(message) {
-    const error = new Error(message + " at character " + this.index);
-    error.index = this.index;
-    error.description = message;
-    throw error;
-  }
-  /**
-   * Run a given hook
-   * @param {string} name
-   * @param {jsep.Expression|false} [node]
-   * @returns {?jsep.Expression}
-   */
-  runHook(name, node) {
-    if (_Jsep.hooks[name]) {
-      const env = { context: this, node };
-      _Jsep.hooks.run(name, env);
-      return env.node;
-    }
-    return node;
-  }
-  /**
-   * Runs a given hook until one returns a node
-   * @param {string} name
-   * @returns {?jsep.Expression}
-   */
-  searchHook(name) {
-    if (_Jsep.hooks[name]) {
-      const env = { context: this };
-      _Jsep.hooks[name].find(function(callback) {
-        callback.call(env.context, env);
-        return env.node;
-      });
-      return env.node;
-    }
-  }
-  /**
-   * Push `index` up to the next non-space character
-   */
-  gobbleSpaces() {
-    let ch = this.code;
-    while (ch === _Jsep.SPACE_CODE || ch === _Jsep.TAB_CODE || ch === _Jsep.LF_CODE || ch === _Jsep.CR_CODE) {
-      ch = this.expr.charCodeAt(++this.index);
-    }
-    this.runHook("gobble-spaces");
-  }
-  /**
-   * Top-level method to parse all expressions and returns compound or single node
-   * @returns {jsep.Expression}
-   */
-  parse() {
-    this.runHook("before-all");
-    const nodes = this.gobbleExpressions();
-    const node = nodes.length === 1 ? nodes[0] : {
-      type: _Jsep.COMPOUND,
-      body: nodes
-    };
-    return this.runHook("after-all", node);
-  }
-  /**
-   * top-level parser (but can be reused within as well)
-   * @param {number} [untilICode]
-   * @returns {jsep.Expression[]}
-   */
-  gobbleExpressions(untilICode) {
-    let nodes = [], ch_i, node;
-    while (this.index < this.expr.length) {
-      ch_i = this.code;
-      if (ch_i === _Jsep.SEMCOL_CODE || ch_i === _Jsep.COMMA_CODE) {
-        this.index++;
-      } else {
-        if (node = this.gobbleExpression()) {
-          nodes.push(node);
-        } else if (this.index < this.expr.length) {
-          if (ch_i === untilICode) {
-            break;
-          }
-          this.throwError('Unexpected "' + this.char + '"');
-        }
-      }
-    }
-    return nodes;
-  }
-  /**
-   * The main parsing function.
-   * @returns {?jsep.Expression}
-   */
-  gobbleExpression() {
-    const node = this.searchHook("gobble-expression") || this.gobbleBinaryExpression();
-    this.gobbleSpaces();
-    return this.runHook("after-expression", node);
-  }
-  /**
-   * Search for the operation portion of the string (e.g. `+`, `===`)
-   * Start by taking the longest possible binary operations (3 characters: `===`, `!==`, `>>>`)
-   * and move down from 3 to 2 to 1 character until a matching binary operation is found
-   * then, return that binary operation
-   * @returns {string|boolean}
-   */
-  gobbleBinaryOp() {
-    this.gobbleSpaces();
-    let to_check = this.expr.substr(this.index, _Jsep.max_binop_len);
-    let tc_len = to_check.length;
-    while (tc_len > 0) {
-      if (_Jsep.binary_ops.hasOwnProperty(to_check) && (!_Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !_Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {
-        this.index += tc_len;
-        return to_check;
-      }
-      to_check = to_check.substr(0, --tc_len);
-    }
-    return false;
-  }
-  /**
-   * This function is responsible for gobbling an individual expression,
-   * e.g. `1`, `1+2`, `a+(b*2)-Math.sqrt(2)`
-   * @returns {?jsep.BinaryExpression}
-   */
-  gobbleBinaryExpression() {
-    let node, biop, prec, stack, biop_info, left, right, i, cur_biop;
-    left = this.gobbleToken();
-    if (!left) {
-      return left;
-    }
-    biop = this.gobbleBinaryOp();
-    if (!biop) {
-      return left;
-    }
-    biop_info = { value: biop, prec: _Jsep.binaryPrecedence(biop), right_a: _Jsep.right_associative.has(biop) };
-    right = this.gobbleToken();
-    if (!right) {
-      this.throwError("Expected expression after " + biop);
-    }
-    stack = [left, biop_info, right];
-    while (biop = this.gobbleBinaryOp()) {
-      prec = _Jsep.binaryPrecedence(biop);
-      if (prec === 0) {
-        this.index -= biop.length;
-        break;
-      }
-      biop_info = { value: biop, prec, right_a: _Jsep.right_associative.has(biop) };
-      cur_biop = biop;
-      const comparePrev = (prev) => biop_info.right_a && prev.right_a ? prec > prev.prec : prec <= prev.prec;
-      while (stack.length > 2 && comparePrev(stack[stack.length - 2])) {
-        right = stack.pop();
-        biop = stack.pop().value;
-        left = stack.pop();
-        node = {
-          type: _Jsep.BINARY_EXP,
-          operator: biop,
-          left,
-          right
-        };
-        stack.push(node);
-      }
-      node = this.gobbleToken();
-      if (!node) {
-        this.throwError("Expected expression after " + cur_biop);
-      }
-      stack.push(biop_info, node);
-    }
-    i = stack.length - 1;
-    node = stack[i];
-    while (i > 1) {
-      node = {
-        type: _Jsep.BINARY_EXP,
-        operator: stack[i - 1].value,
-        left: stack[i - 2],
-        right: node
-      };
-      i -= 2;
-    }
-    return node;
-  }
-  /**
-   * An individual part of a binary expression:
-   * e.g. `foo.bar(baz)`, `1`, `"abc"`, `(a % 2)` (because it's in parenthesis)
-   * @returns {boolean|jsep.Expression}
-   */
-  gobbleToken() {
-    let ch, to_check, tc_len, node;
-    this.gobbleSpaces();
-    node = this.searchHook("gobble-token");
-    if (node) {
-      return this.runHook("after-token", node);
-    }
-    ch = this.code;
-    if (_Jsep.isDecimalDigit(ch) || ch === _Jsep.PERIOD_CODE) {
-      return this.gobbleNumericLiteral();
-    }
-    if (ch === _Jsep.SQUOTE_CODE || ch === _Jsep.DQUOTE_CODE) {
-      node = this.gobbleStringLiteral();
-    } else if (ch === _Jsep.OBRACK_CODE) {
-      node = this.gobbleArray();
-    } else {
-      to_check = this.expr.substr(this.index, _Jsep.max_unop_len);
-      tc_len = to_check.length;
-      while (tc_len > 0) {
-        if (_Jsep.unary_ops.hasOwnProperty(to_check) && (!_Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !_Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {
-          this.index += tc_len;
-          const argument = this.gobbleToken();
-          if (!argument) {
-            this.throwError("missing unaryOp argument");
-          }
-          return this.runHook("after-token", {
-            type: _Jsep.UNARY_EXP,
-            operator: to_check,
-            argument,
-            prefix: true
-          });
-        }
-        to_check = to_check.substr(0, --tc_len);
-      }
-      if (_Jsep.isIdentifierStart(ch)) {
-        node = this.gobbleIdentifier();
-        if (_Jsep.literals.hasOwnProperty(node.name)) {
-          node = {
-            type: _Jsep.LITERAL,
-            value: _Jsep.literals[node.name],
-            raw: node.name
-          };
-        } else if (node.name === _Jsep.this_str) {
-          node = { type: _Jsep.THIS_EXP };
-        }
-      } else if (ch === _Jsep.OPAREN_CODE) {
-        node = this.gobbleGroup();
-      }
-    }
-    if (!node) {
-      return this.runHook("after-token", false);
-    }
-    node = this.gobbleTokenProperty(node);
-    return this.runHook("after-token", node);
-  }
-  /**
-   * Gobble properties of of identifiers/strings/arrays/groups.
-   * e.g. `foo`, `bar.baz`, `foo['bar'].baz`
-   * It also gobbles function calls:
-   * e.g. `Math.acos(obj.angle)`
-   * @param {jsep.Expression} node
-   * @returns {jsep.Expression}
-   */
-  gobbleTokenProperty(node) {
-    this.gobbleSpaces();
-    let ch = this.code;
-    while (ch === _Jsep.PERIOD_CODE || ch === _Jsep.OBRACK_CODE || ch === _Jsep.OPAREN_CODE || ch === _Jsep.QUMARK_CODE) {
-      let optional;
-      if (ch === _Jsep.QUMARK_CODE) {
-        if (this.expr.charCodeAt(this.index + 1) !== _Jsep.PERIOD_CODE) {
-          break;
-        }
-        optional = true;
-        this.index += 2;
-        this.gobbleSpaces();
-        ch = this.code;
-      }
-      this.index++;
-      if (ch === _Jsep.OBRACK_CODE) {
-        node = {
-          type: _Jsep.MEMBER_EXP,
-          computed: true,
-          object: node,
-          property: this.gobbleExpression()
-        };
-        if (!node.property) {
-          this.throwError('Unexpected "' + this.char + '"');
-        }
-        this.gobbleSpaces();
-        ch = this.code;
-        if (ch !== _Jsep.CBRACK_CODE) {
-          this.throwError("Unclosed [");
-        }
-        this.index++;
-      } else if (ch === _Jsep.OPAREN_CODE) {
-        node = {
-          type: _Jsep.CALL_EXP,
-          "arguments": this.gobbleArguments(_Jsep.CPAREN_CODE),
-          callee: node
-        };
-      } else if (ch === _Jsep.PERIOD_CODE || optional) {
-        if (optional) {
-          this.index--;
-        }
-        this.gobbleSpaces();
-        node = {
-          type: _Jsep.MEMBER_EXP,
-          computed: false,
-          object: node,
-          property: this.gobbleIdentifier()
-        };
-      }
-      if (optional) {
-        node.optional = true;
-      }
-      this.gobbleSpaces();
-      ch = this.code;
-    }
-    return node;
-  }
-  /**
-   * Parse simple numeric literals: `12`, `3.4`, `.5`. Do this by using a string to
-   * keep track of everything in the numeric literal and then calling `parseFloat` on that string
-   * @returns {jsep.Literal}
-   */
-  gobbleNumericLiteral() {
-    let number = "", ch, chCode;
-    while (_Jsep.isDecimalDigit(this.code)) {
-      number += this.expr.charAt(this.index++);
-    }
-    if (this.code === _Jsep.PERIOD_CODE) {
-      number += this.expr.charAt(this.index++);
-      while (_Jsep.isDecimalDigit(this.code)) {
-        number += this.expr.charAt(this.index++);
-      }
-    }
-    ch = this.char;
-    if (ch === "e" || ch === "E") {
-      number += this.expr.charAt(this.index++);
-      ch = this.char;
-      if (ch === "+" || ch === "-") {
-        number += this.expr.charAt(this.index++);
-      }
-      while (_Jsep.isDecimalDigit(this.code)) {
-        number += this.expr.charAt(this.index++);
-      }
-      if (!_Jsep.isDecimalDigit(this.expr.charCodeAt(this.index - 1))) {
-        this.throwError("Expected exponent (" + number + this.char + ")");
-      }
-    }
-    chCode = this.code;
-    if (_Jsep.isIdentifierStart(chCode)) {
-      this.throwError("Variable names cannot start with a number (" + number + this.char + ")");
-    } else if (chCode === _Jsep.PERIOD_CODE || number.length === 1 && number.charCodeAt(0) === _Jsep.PERIOD_CODE) {
-      this.throwError("Unexpected period");
-    }
-    return {
-      type: _Jsep.LITERAL,
-      value: parseFloat(number),
-      raw: number
-    };
-  }
-  /**
-   * Parses a string literal, staring with single or double quotes with basic support for escape codes
-   * e.g. `"hello world"`, `'this is\nJSEP'`
-   * @returns {jsep.Literal}
-   */
-  gobbleStringLiteral() {
-    let str = "";
-    const startIndex = this.index;
-    const quote = this.expr.charAt(this.index++);
-    let closed = false;
-    while (this.index < this.expr.length) {
-      let ch = this.expr.charAt(this.index++);
-      if (ch === quote) {
-        closed = true;
-        break;
-      } else if (ch === "\\") {
-        ch = this.expr.charAt(this.index++);
-        switch (ch) {
-          case "n":
-            str += "\n";
-            break;
-          case "r":
-            str += "\r";
-            break;
-          case "t":
-            str += "	";
-            break;
-          case "b":
-            str += "\b";
-            break;
-          case "f":
-            str += "\f";
-            break;
-          case "v":
-            str += "\v";
-            break;
-          default:
-            str += ch;
-        }
-      } else {
-        str += ch;
-      }
-    }
-    if (!closed) {
-      this.throwError('Unclosed quote after "' + str + '"');
-    }
-    return {
-      type: _Jsep.LITERAL,
-      value: str,
-      raw: this.expr.substring(startIndex, this.index)
-    };
-  }
-  /**
-   * Gobbles only identifiers
-   * e.g.: `foo`, `_value`, `$x1`
-   * Also, this function checks if that identifier is a literal:
-   * (e.g. `true`, `false`, `null`) or `this`
-   * @returns {jsep.Identifier}
-   */
-  gobbleIdentifier() {
-    let ch = this.code, start = this.index;
-    if (_Jsep.isIdentifierStart(ch)) {
-      this.index++;
-    } else {
-      this.throwError("Unexpected " + this.char);
-    }
-    while (this.index < this.expr.length) {
-      ch = this.code;
-      if (_Jsep.isIdentifierPart(ch)) {
-        this.index++;
-      } else {
-        break;
-      }
-    }
-    return {
-      type: _Jsep.IDENTIFIER,
-      name: this.expr.slice(start, this.index)
-    };
-  }
-  /**
-   * Gobbles a list of arguments within the context of a function call
-   * or array literal. This function also assumes that the opening character
-   * `(` or `[` has already been gobbled, and gobbles expressions and commas
-   * until the terminator character `)` or `]` is encountered.
-   * e.g. `foo(bar, baz)`, `my_func()`, or `[bar, baz]`
-   * @param {number} termination
-   * @returns {jsep.Expression[]}
-   */
-  gobbleArguments(termination) {
-    const args = [];
-    let closed = false;
-    let separator_count = 0;
-    while (this.index < this.expr.length) {
-      this.gobbleSpaces();
-      let ch_i = this.code;
-      if (ch_i === termination) {
-        closed = true;
-        this.index++;
-        if (termination === _Jsep.CPAREN_CODE && separator_count && separator_count >= args.length) {
-          this.throwError("Unexpected token " + String.fromCharCode(termination));
-        }
-        break;
-      } else if (ch_i === _Jsep.COMMA_CODE) {
-        this.index++;
-        separator_count++;
-        if (separator_count !== args.length) {
-          if (termination === _Jsep.CPAREN_CODE) {
-            this.throwError("Unexpected token ,");
-          } else if (termination === _Jsep.CBRACK_CODE) {
-            for (let arg = args.length; arg < separator_count; arg++) {
-              args.push(null);
-            }
-          }
-        }
-      } else if (args.length !== separator_count && separator_count !== 0) {
-        this.throwError("Expected comma");
-      } else {
-        const node = this.gobbleExpression();
-        if (!node || node.type === _Jsep.COMPOUND) {
-          this.throwError("Expected comma");
-        }
-        args.push(node);
-      }
-    }
-    if (!closed) {
-      this.throwError("Expected " + String.fromCharCode(termination));
-    }
-    return args;
-  }
-  /**
-   * Responsible for parsing a group of things within parentheses `()`
-   * that have no identifier in front (so not a function call)
-   * This function assumes that it needs to gobble the opening parenthesis
-   * and then tries to gobble everything within that parenthesis, assuming
-   * that the next thing it should see is the close parenthesis. If not,
-   * then the expression probably doesn't have a `)`
-   * @returns {boolean|jsep.Expression}
-   */
-  gobbleGroup() {
-    this.index++;
-    let nodes = this.gobbleExpressions(_Jsep.CPAREN_CODE);
-    if (this.code === _Jsep.CPAREN_CODE) {
-      this.index++;
-      if (nodes.length === 1) {
-        return nodes[0];
-      } else if (!nodes.length) {
-        return false;
-      } else {
-        return {
-          type: _Jsep.SEQUENCE_EXP,
-          expressions: nodes
-        };
-      }
-    } else {
-      this.throwError("Unclosed (");
-    }
-  }
-  /**
-   * Responsible for parsing Array literals `[1, 2, 3]`
-   * This function assumes that it needs to gobble the opening bracket
-   * and then tries to gobble the expressions as arguments.
-   * @returns {jsep.ArrayExpression}
-   */
-  gobbleArray() {
-    this.index++;
-    return {
-      type: _Jsep.ARRAY_EXP,
-      elements: this.gobbleArguments(_Jsep.CBRACK_CODE)
-    };
-  }
-};
-var hooks = new Hooks();
-Object.assign(Jsep, {
-  hooks,
-  plugins: new Plugins(Jsep),
-  // Node Types
-  // ----------
-  // This is the full set of types that any JSEP node can be.
-  // Store them here to save space when minified
-  COMPOUND: "Compound",
-  SEQUENCE_EXP: "SequenceExpression",
-  IDENTIFIER: "Identifier",
-  MEMBER_EXP: "MemberExpression",
-  LITERAL: "Literal",
-  THIS_EXP: "ThisExpression",
-  CALL_EXP: "CallExpression",
-  UNARY_EXP: "UnaryExpression",
-  BINARY_EXP: "BinaryExpression",
-  ARRAY_EXP: "ArrayExpression",
-  TAB_CODE: 9,
-  LF_CODE: 10,
-  CR_CODE: 13,
-  SPACE_CODE: 32,
-  PERIOD_CODE: 46,
-  // '.'
-  COMMA_CODE: 44,
-  // ','
-  SQUOTE_CODE: 39,
-  // single quote
-  DQUOTE_CODE: 34,
-  // double quotes
-  OPAREN_CODE: 40,
-  // (
-  CPAREN_CODE: 41,
-  // )
-  OBRACK_CODE: 91,
-  // [
-  CBRACK_CODE: 93,
-  // ]
-  QUMARK_CODE: 63,
-  // ?
-  SEMCOL_CODE: 59,
-  // ;
-  COLON_CODE: 58,
-  // :
-  // Operations
-  // ----------
-  // Use a quickly-accessible map to store all of the unary operators
-  // Values are set to `1` (it really doesn't matter)
-  unary_ops: {
-    "-": 1,
-    "!": 1,
-    "~": 1,
-    "+": 1
-  },
-  // Also use a map for the binary operations but set their values to their
-  // binary precedence for quick reference (higher number = higher precedence)
-  // see [Order of operations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)
-  binary_ops: {
-    "||": 1,
-    "??": 1,
-    "&&": 2,
-    "|": 3,
-    "^": 4,
-    "&": 5,
-    "==": 6,
-    "!=": 6,
-    "===": 6,
-    "!==": 6,
-    "<": 7,
-    ">": 7,
-    "<=": 7,
-    ">=": 7,
-    "<<": 8,
-    ">>": 8,
-    ">>>": 8,
-    "+": 9,
-    "-": 9,
-    "*": 10,
-    "/": 10,
-    "%": 10,
-    "**": 11
-  },
-  // sets specific binary_ops as right-associative
-  right_associative: /* @__PURE__ */ new Set(["**"]),
-  // Additional valid identifier chars, apart from a-z, A-Z and 0-9 (except on the starting char)
-  additional_identifier_chars: /* @__PURE__ */ new Set(["$", "_"]),
-  // Literals
-  // ----------
-  // Store the values to return for the various literals we may encounter
-  literals: {
-    "true": true,
-    "false": false,
-    "null": null
-  },
-  // Except for `this`, which is special. This could be changed to something like `'self'` as well
-  this_str: "this"
-});
-Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);
-Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);
-var jsep = (expr) => new Jsep(expr).parse();
-var stdClassProps = Object.getOwnPropertyNames(class Test {
-});
-Object.getOwnPropertyNames(Jsep).filter((prop) => !stdClassProps.includes(prop) && jsep[prop] === void 0).forEach((m) => {
-  jsep[m] = Jsep[m];
-});
-jsep.Jsep = Jsep;
-var CONDITIONAL_EXP = "ConditionalExpression";
-var ternary = {
-  name: "ternary",
-  init(jsep2) {
-    jsep2.hooks.add("after-expression", function gobbleTernary(env) {
-      if (env.node && this.code === jsep2.QUMARK_CODE) {
-        this.index++;
-        const test = env.node;
-        const consequent = this.gobbleExpression();
-        if (!consequent) {
-          this.throwError("Expected expression");
-        }
-        this.gobbleSpaces();
-        if (this.code === jsep2.COLON_CODE) {
-          this.index++;
-          const alternate = this.gobbleExpression();
-          if (!alternate) {
-            this.throwError("Expected expression");
-          }
-          env.node = {
-            type: CONDITIONAL_EXP,
-            test,
-            consequent,
-            alternate
-          };
-          if (test.operator && jsep2.binary_ops[test.operator] <= 0.9) {
-            let newTest = test;
-            while (newTest.right.operator && jsep2.binary_ops[newTest.right.operator] <= 0.9) {
-              newTest = newTest.right;
-            }
-            env.node.test = newTest.right;
-            newTest.right = env.node;
-            env.node = test;
-          }
-        } else {
-          this.throwError("Expected :");
-        }
-      }
-    });
-  }
-};
-jsep.plugins.register(ternary);
-
-// ../hegel/dist/index.js
-Array.prototype.mapNotNull = function(callback) {
-  return this.map(callback).filter((item) => item != null);
-};
-Array.prototype.cast = function() {
-  return this;
-};
-
-// src/taxonomiesRelationshipFields.ts
-var taxonomyRelationship = {
-  name: "categories",
-  label: "Categor\xEDas",
-  type: "relationship",
-  relationTo: COLLECTION_SLUG_TAXONOMY,
-  defaultValue: [],
-  hasMany: true,
-  required: false
-};
-
-// src/buildTaxonomizedCollection.ts
-var buildTaxonomizedCollection = (config) => {
-  const protoConfigCollection = {
-    ...config,
-    fields: [taxonomyRelationship, ...config.fields]
-  };
-  return protoConfigCollection;
-};
-export {
-  COLLECTION_SLUG_TAXONOMY,
-  buildTaxonomizedCollection,
-  taxonomiesCollection,
-  taxonomyRelationship
-};
+export { taxonomiesCollection } from "./taxonomy";
+export { COLLECTION_SLUG_TAXONOMY } from "./taxonomy";
+export { buildTaxonomizedCollection } from "./buildTaxonomizedCollection";
+export { taxonomyRelationship } from "./taxonomiesRelationshipFields";