@react-awesome-query-builder/core/cjs/export/queryString.js

User-friendly query builder for React. Core

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.queryString = void 0;
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
var _configUtils = require("../utils/configUtils");
var _configExtend = require("../utils/configExtend");
var _ruleUtils = require("../utils/ruleUtils");
var _pick = _interopRequireDefault(require("lodash/pick"));
var _stuff = require("../utils/stuff");
var _defaultUtils = require("../utils/defaultUtils");
var _immutable = require("immutable");
function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
var queryString = exports.queryString = function queryString(item, config) {
  var isForDisplay = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  var isDebugMode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
  //meta is mutable
  var meta = {
    errors: [],
    settings: {
      isForDisplay: isForDisplay,
      isDebugMode: isDebugMode
    }
  };
  var extendedConfig = (0, _configExtend.extendConfig)(config, undefined, false);
  var res = formatItem([], item, extendedConfig, meta, null);
  if (meta.errors.length) console.warn("Errors while exporting to string:", meta.errors);
  return res;
};
var formatItem = function formatItem(parents, item, config, meta) {
  var parentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
  if (!item) return undefined;
  var type = item.get("type");
  var children = item.get("children1");
  if (type === "group" || type === "rule_group") {
    return formatGroup(parents, item, config, meta, parentField);
  } else if (type === "rule") {
    return formatRule(parents, item, config, meta, parentField);
  }
  return undefined;
};
var formatGroup = function formatGroup(parents, item, config, meta) {
  var _config$operators$gro, _config$operators$gro2;
  var parentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
  var _meta$settings = meta.settings,
    isForDisplay = _meta$settings.isForDisplay,
    isDebugMode = _meta$settings.isDebugMode;
  var type = item.get("type");
  var properties = item.get("properties") || new _immutable.Map();
  var mode = properties.get("mode");
  var children = item.get("children1") || new _immutable.List();

  // const parentRuleGroup = parents.filter(it => it.get("type") == "rule_group")?.slice(-1)?.pop();
  // const isInsideRuleGroup = !!parentRuleGroup;
  // const parentRuleGroupField = parentRuleGroup?.get("properties").get("field");
  // const isInsideRuleGroupArray = isInsideRuleGroup && parentRuleGroup.get("properties").get("mode") == "array";
  // // TIP: don't cut group for mode == 'struct'
  // const realParentGroupField = isInsideRuleGroupArray && parentRuleGroupField;
  var realParentGroupField = parentField;
  var isRuleGroup = type === "rule_group";
  // TIP: don't cut group for mode == 'struct' and don't do aggr format (maybe later)
  var groupField = isRuleGroup && mode == "array" ? properties.get("field") : null;
  var groupOperator = type === "rule_group" ? properties.get("operator") : null;
  var groupOperatorCardinality = groupOperator ? (_config$operators$gro = (_config$operators$gro2 = config.operators[groupOperator]) === null || _config$operators$gro2 === void 0 ? void 0 : _config$operators$gro2.cardinality) !== null && _config$operators$gro !== void 0 ? _config$operators$gro : 1 : undefined;
  var canHaveEmptyChildren = isRuleGroup && mode === "array" && groupOperatorCardinality >= 1;
  var not = properties.get("not");
  var list = children.map(function (currentChild) {
    return formatItem([].concat((0, _toConsumableArray2["default"])(parents), [item]), currentChild, config, meta, groupField !== null && groupField !== void 0 ? groupField : realParentGroupField);
  }).filter(function (currentChild) {
    return typeof currentChild !== "undefined";
  });
  if (!canHaveEmptyChildren && !list.size && !isDebugMode) {
    return undefined;
  }
  var conjunction = properties.get("conjunction");
  if (!conjunction) conjunction = (0, _defaultUtils.defaultConjunction)(config);
  var conjunctionDefinition = config.conjunctions[conjunction];
  var conjStr = list.size ? conjunctionDefinition.formatConj.call(config.ctx, list, conjunction, not, isForDisplay) : null;
  var ret;
  if (groupField) {
    var aggrArgs = formatRule(parents, item, config, meta, realParentGroupField, true);
    if (aggrArgs) {
      var _config$settings$form;
      var isRev = aggrArgs.pop();
      var args = [conjStr].concat((0, _toConsumableArray2["default"])(aggrArgs));
      ret = (_config$settings$form = config.settings.formatAggr).call.apply(_config$settings$form, [config.ctx].concat((0, _toConsumableArray2["default"])(args)));
      if (isRev) {
        ret = config.settings.formatReverse.call(config.ctx, ret, null, null, null, null, isForDisplay);
      }
    }
  } else {
    ret = conjStr;
  }
  if (isDebugMode && ret == null) {
    ret = "?";
  }
  return ret;
};
var formatItemValue = function formatItemValue(config, properties, meta, _operator, parentField) {
  var _meta$settings2 = meta.settings,
    isForDisplay = _meta$settings2.isForDisplay,
    isDebugMode = _meta$settings2.isDebugMode;
  var field = properties.get("field");
  var iValueSrc = properties.get("valueSrc");
  var iValueType = properties.get("valueType");
  var fieldDef = (0, _configUtils.getFieldConfig)(config, field) || {};
  var operator = _operator || properties.get("operator");
  var operatorDef = (0, _configUtils.getOperatorConfig)(config, operator, field) || {};
  var cardinality = (0, _stuff.getOpCardinality)(operatorDef);
  var iValue = properties.get("value");
  var asyncListValues = properties.get("asyncListValues");
  var valueSrcs = [];
  var valueTypes = [];
  var formattedValue;
  var fvalue;
  if (iValue != undefined) {
    fvalue = iValue.map(function (currentValue, ind) {
      var valueSrc = iValueSrc ? iValueSrc.get(ind) : null;
      var valueType = iValueType ? iValueType.get(ind) : null;
      var cValue = !isDebugMode ? (0, _ruleUtils.completeValue)(currentValue, valueSrc, config) : currentValue;
      var widget = (0, _configUtils.getWidgetForFieldOp)(config, field, operator, valueSrc);
      var fieldWidgetDef = (0, _configUtils.getFieldWidgetConfig)(config, field, operator, widget, valueSrc, {
        forExport: true
      });
      var fv = formatValue(config, meta, cValue, valueSrc, valueType, fieldWidgetDef, fieldDef, operator, operatorDef, parentField, asyncListValues);
      if (fv !== undefined) {
        valueSrcs.push(valueSrc);
        valueTypes.push(valueType);
      }
      return fv;
    });
    var hasUndefinedValues = fvalue.filter(function (v) {
      return v === undefined;
    }).size > 0;
    var isOK = !hasUndefinedValues && fvalue.size === cardinality;
    if (isOK) {
      formattedValue = cardinality == 1 ? fvalue.first() : fvalue;
    }
  }
  if (isDebugMode && !formattedValue) {
    formattedValue = cardinality > 1 ? new _immutable.List(Array.from({
      length: cardinality
    }).map(function (_, i) {
      var _fvalue$get, _fvalue;
      return (_fvalue$get = (_fvalue = fvalue) === null || _fvalue === void 0 ? void 0 : _fvalue.get(i)) !== null && _fvalue$get !== void 0 ? _fvalue$get : "?";
    })) : "?";
  }
  return [formattedValue, valueSrcs.length > 1 ? valueSrcs : valueSrcs[0], valueTypes.length > 1 ? valueTypes : valueTypes[0]];
};
var buildFnToFormatOp = function buildFnToFormatOp(operator, operatorDefinition, meta) {
  var isDebugMode = meta.settings.isDebugMode;
  var fop = (operatorDefinition === null || operatorDefinition === void 0 ? void 0 : operatorDefinition.labelForFormat) || operator;
  var cardinality = (0, _stuff.getOpCardinality)(operatorDefinition);
  var fn;
  if (cardinality == 0) {
    fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {
      return "".concat(field, " ").concat(fop);
    };
  } else if (cardinality == 1) {
    fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {
      if (isDebugMode && op === "?" && values === "?") {
        return field && field !== "?" ? "".concat(field, " ?") : "?";
      }
      return "".concat(field, " ").concat(fop, " ").concat(values);
    };
  } else if (cardinality == 2) {
    // between
    fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {
      var _values$first, _values$get;
      var valFrom = values === null || values === void 0 || (_values$first = values.first) === null || _values$first === void 0 ? void 0 : _values$first.call(values);
      var valTo = values === null || values === void 0 || (_values$get = values.get) === null || _values$get === void 0 ? void 0 : _values$get.call(values, 1);
      return "".concat(field, " ").concat(fop, " ").concat(valFrom, " AND ").concat(valTo);
    };
  }
  return fn;
};
var formatRule = function formatRule(parents, item, config, meta) {
  var parentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
  var returnArgs = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
  var _meta$settings3 = meta.settings,
    isForDisplay = _meta$settings3.isForDisplay,
    isDebugMode = _meta$settings3.isDebugMode;
  var properties = item.get("properties") || new _immutable.Map();
  var field = properties.get("field");
  var fieldSrc = properties.get("fieldSrc");
  var operator = properties.get("operator");
  var operatorOptions = properties.get("operatorOptions");
  if ((field == null || operator == null) && !isDebugMode) return undefined;
  var fieldDef = (0, _configUtils.getFieldConfig)(config, field) || {};
  var operatorDef = (0, _configUtils.getOperatorConfig)(config, operator, field) || {};
  var reversedOp = operatorDef.reversedOp;
  var revOperatorDef = (0, _configUtils.getOperatorConfig)(config, reversedOp, field) || {};

  //check op
  var isRev = false;
  var fn = operatorDef.formatOp;
  if (!fn && reversedOp) {
    fn = revOperatorDef.formatOp;
    if (fn) {
      isRev = true;
      var _ref = [reversedOp, operator];
      operator = _ref[0];
      reversedOp = _ref[1];
      var _ref2 = [revOperatorDef, operatorDef];
      operatorDef = _ref2[0];
      revOperatorDef = _ref2[1];
    }
  }
  if (isDebugMode && !operator) {
    operator = "?";
  }

  //find fn to format expr
  if (!fn) fn = buildFnToFormatOp(operator, operatorDef, meta);
  if (!fn) return undefined;

  //format field
  var formattedField = fieldSrc === "func" ? formatFunc(config, meta, field, parentField) : formatField(config, meta, field, parentField);
  if (formattedField == undefined) return undefined;

  //format value
  var _formatItemValue = formatItemValue(config, properties, meta, operator, parentField),
    _formatItemValue2 = (0, _slicedToArray2["default"])(_formatItemValue, 3),
    formattedValue = _formatItemValue2[0],
    valueSrc = _formatItemValue2[1],
    valueType = _formatItemValue2[2];
  if (formattedValue === undefined) {
    return undefined;
  }
  var args = [formattedField, operator, formattedValue, valueSrc, valueType, (0, _stuff.omit)(operatorDef, _stuff.opDefKeysToOmit), operatorOptions, isForDisplay, fieldDef, isRev];
  if (returnArgs) {
    return args;
  } else {
    var _fn;
    //format expr
    var ret = (_fn = fn).call.apply(_fn, [config.ctx].concat(args));

    //rev
    if (isRev) {
      ret = config.settings.formatReverse.call(config.ctx, ret, operator, reversedOp, operatorDef, revOperatorDef, isForDisplay);
    }
    return ret;
  }
};
var formatValue = function formatValue(config, meta, value, valueSrc, valueType, fieldWidgetDef, fieldDef, operator, opDef) {
  var parentField = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : null;
  var asyncListValues = arguments.length > 10 ? arguments[10] : undefined;
  var _meta$settings4 = meta.settings,
    isForDisplay = _meta$settings4.isForDisplay,
    isDebugMode = _meta$settings4.isDebugMode;
  if (value === undefined) {
    if (isDebugMode) {
      if ((fieldWidgetDef === null || fieldWidgetDef === void 0 ? void 0 : fieldWidgetDef.jsType) === "array") {
        return [];
      }
      return "?";
    } else {
      return undefined;
    }
  }
  var ret;
  if (valueSrc == "field") {
    ret = formatField(config, meta, value, parentField);
  } else if (valueSrc == "func") {
    ret = formatFunc(config, meta, value, parentField);
  } else if (value == undefined) {
    ret = undefined;
  } else {
    if (typeof (fieldWidgetDef === null || fieldWidgetDef === void 0 ? void 0 : fieldWidgetDef.formatValue) === "function") {
      var _fieldDef$escapeForFo;
      var fn = fieldWidgetDef.formatValue;
      var args = [value, _objectSpread(_objectSpread({}, (0, _pick["default"])(fieldDef, ["fieldSettings", "listValues"])), {}, {
        asyncListValues: asyncListValues
      }),
      //useful options: valueFormat for date/time
      (0, _stuff.omit)(fieldWidgetDef, _stuff.widgetDefKeysToOmit), isForDisplay];
      if (operator) {
        args.push(operator);
        args.push(opDef);
      }
      if (valueSrc == "field") {
        var valFieldDefinition = (0, _configUtils.getFieldConfig)(config, value) || {};
        args.push(valFieldDefinition);
      }
      var doEscape = (_fieldDef$escapeForFo = fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.escapeForFormat) !== null && _fieldDef$escapeForFo !== void 0 ? _fieldDef$escapeForFo : true;
      if (!doEscape) {
        ret = value;
      } else {
        ret = fn.call.apply(fn, [config.ctx].concat(args));
      }
    } else {
      ret = value;
    }
  }
  return ret;
};
var formatField = function formatField(config, meta, field) {
  var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var cutParentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
  var _meta$settings5 = meta.settings,
    isForDisplay = _meta$settings5.isForDisplay,
    isDebugMode = _meta$settings5.isDebugMode;
  var _config$settings = config.settings,
    fieldSeparator = _config$settings.fieldSeparator,
    fieldSeparatorDisplay = _config$settings.fieldSeparatorDisplay;
  var ret = null;
  if (field) {
    var fieldDefinition = (0, _configUtils.getFieldConfig)(config, field) || {};
    var fieldParts = (0, _configUtils.getFieldParts)(field, config);
    var fieldPartsLabels = (0, _ruleUtils.getFieldPathLabels)(field, config, cutParentField ? parentField : null);
    var fieldFullLabel = fieldPartsLabels ? fieldPartsLabels.join(fieldSeparatorDisplay) : null;
    var fieldLabel2 = fieldDefinition.label2 || fieldFullLabel;
    var formatFieldFn = config.settings.formatField;
    var fieldName = (0, _ruleUtils.formatFieldName)(field, config, meta, cutParentField ? parentField : null, {
      useTableName: true
    });
    ret = formatFieldFn(fieldName, fieldParts, fieldLabel2, fieldDefinition, config, isForDisplay);
  } else if (isDebugMode) {
    ret = "?";
  }
  return ret;
};
var formatFunc = function formatFunc(config, meta, funcValue) {
  var _funcValue$get, _funcValue$get2, _args$keySeq;
  var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var _meta$settings6 = meta.settings,
    isForDisplay = _meta$settings6.isForDisplay,
    isDebugMode = _meta$settings6.isDebugMode;
  var funcKey = funcValue === null || funcValue === void 0 || (_funcValue$get = funcValue.get) === null || _funcValue$get === void 0 ? void 0 : _funcValue$get.call(funcValue, "func");
  if (!funcKey) {
    return isDebugMode ? "?()" : undefined;
  }
  var args = (_funcValue$get2 = funcValue.get) === null || _funcValue$get2 === void 0 ? void 0 : _funcValue$get2.call(funcValue, "args");
  var funcConfig = (0, _configUtils.getFuncConfig)(config, funcKey);
  if (!funcConfig) {
    if (!isDebugMode) {
      meta.errors.push("Func ".concat(funcKey, " is not defined in config"));
      return undefined;
    }
  }
  var funcParts = (0, _configUtils.getFieldParts)(funcKey, config);
  var funcLastKey = funcParts[funcParts.length - 1];
  var funcName = isForDisplay && (funcConfig === null || funcConfig === void 0 ? void 0 : funcConfig.label) || funcLastKey;
  var formattedArgs = {};
  var gaps = [];
  var missingArgKeys = [];
  var formattedArgsWithNames = {};
  var argsKeys = funcConfig ? Object.keys(funcConfig.args || {}) : (args === null || args === void 0 || (_args$keySeq = args.keySeq) === null || _args$keySeq === void 0 ? void 0 : _args$keySeq.call(args).toArray()) || [];
  var _iterator = _createForOfIteratorHelper(argsKeys),
    _step;
  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var _argValue;
      var argKey = _step.value;
      var argConfig = funcConfig === null || funcConfig === void 0 ? void 0 : funcConfig.args[argKey];
      var fieldDef = (0, _configUtils.getFieldConfig)(config, argConfig);
      var _ref5 = argConfig || {},
        defaultValue = _ref5.defaultValue,
        isOptional = _ref5.isOptional;
      var defaultValueSrc = defaultValue !== null && defaultValue !== void 0 && defaultValue.func ? "func" : "value";
      var fieldWidgetDef = (0, _configUtils.getFieldWidgetConfig)(config, argConfig, undefined, undefined, defaultValueSrc, {
        forExport: true
      });
      var argName = isForDisplay && (argConfig === null || argConfig === void 0 ? void 0 : argConfig.label) || argKey;
      var argVal = args ? args.get(argKey) : undefined;
      var argValue = argVal ? argVal.get("value") : undefined;
      var argValueSrc = argVal ? argVal.get("valueSrc") : undefined;
      if (argValueSrc !== "func" && (_argValue = argValue) !== null && _argValue !== void 0 && _argValue.toJS) {
        // value should not be Immutable
        argValue = argValue.toJS();
      }
      var argAsyncListValues = argVal ? argVal.get("asyncListValues") : undefined;
      var formattedArgVal = formatValue(config, meta, argValue, argValueSrc, argConfig === null || argConfig === void 0 ? void 0 : argConfig.type, fieldWidgetDef, argConfig, null, null, parentField, argAsyncListValues);
      if (argValue != undefined && formattedArgVal === undefined) {
        if (argValueSrc != "func")
          // don't triger error if args value is another incomplete function
          meta.errors.push("Can't format value of arg ".concat(argKey, " for func ").concat(funcKey));
      }
      var formattedDefaultVal = void 0;
      if (formattedArgVal === undefined && !isOptional && defaultValue != undefined) {
        formattedDefaultVal = formatValue(config, meta, defaultValue, defaultValueSrc, argConfig === null || argConfig === void 0 ? void 0 : argConfig.type, fieldWidgetDef, argConfig, null, null, parentField, argAsyncListValues);
        if (formattedDefaultVal === undefined) {
          if (defaultValueSrc != "func")
            // don't triger error if args value is another incomplete function
            meta.errors.push("Can't format default value of arg ".concat(argKey, " for func ").concat(funcKey));
          return undefined;
        }
      }
      var finalFormattedVal = formattedArgVal !== null && formattedArgVal !== void 0 ? formattedArgVal : formattedDefaultVal;
      if (finalFormattedVal !== undefined) {
        if (gaps.length) {
          var _iterator2 = _createForOfIteratorHelper(argKey),
            _step2;
          try {
            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
              var _step2$value = (0, _slicedToArray2["default"])(_step2.value, 2),
                missedArgKey = _step2$value[0],
                missedArgName = _step2$value[1];
              formattedArgs[missedArgKey] = undefined;
              //formattedArgsWithNames[missedArgName] = undefined;
            }
          } catch (err) {
            _iterator2.e(err);
          } finally {
            _iterator2.f();
          }
          gaps = [];
        }
        formattedArgs[argKey] = finalFormattedVal;
        formattedArgsWithNames[argName] = finalFormattedVal;
      } else {
        if (!isOptional) missingArgKeys.push(argKey);
        gaps.push([argKey, argName]);
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
  if (missingArgKeys.length) {
    //meta.errors.push(`Missing vals for args ${missingArgKeys.join(", ")} for func ${funcKey}`);
    if (!isDebugMode) {
      return undefined; // incomplete
    }
  }
  var ret = null;
  if (typeof (funcConfig === null || funcConfig === void 0 ? void 0 : funcConfig.formatFunc) === "function") {
    var fn = funcConfig.formatFunc;
    var _args = [formattedArgs, isForDisplay];
    ret = fn.call.apply(fn, [config.ctx].concat(_args));
  } else {
    var argsStr = Object.entries(isForDisplay ? formattedArgsWithNames : formattedArgs).map(function (_ref3) {
      var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
        k = _ref4[0],
        v = _ref4[1];
      return isForDisplay ? "".concat(k, ": ").concat(v) : "".concat(v);
    }).join(", ");
    ret = "".concat(funcName, "(").concat(argsStr, ")");
  }
  return ret;
};