Convenient method to stringify a rule.
@returns {string}
424144
function() {
        var factConj = '';
        for(var key in this.causes) {
            factConj += ' ^ ' + this.causes[key].toString().substring(1).replace(/,/g, '');
        }
        for(var key in this.operatorCauses) {
            factConj += ' ^ ' + this.operatorCauses[key].toString().substring(1).replace(/,/g, '');
        }
        return factConj.substr(3) + ' -> ' + this.consequences.toString().substring(1).replace(/,/g, '');
    }
1039871
function stringify(validations) {
    if (!validations) { return ''; }

    return JSON.stringify(validations, function (key, value) {
        if (_.isRegExp(value)) { return value.toString(); }

        switch (value) {
            case String:    return 'String';
            case Boolean:   return 'Boolean';
            case Date:      return 'Date';
            case Number:    return 'Number';
            default:        return value;
        }
    });
}
987822
function stringify(
	v
	, propertyMask	//# noPropertyMask!
	, limit
) {
	if ( v === undefined ) { return undefined ; }

	var runtime = {
		str: ''
		, depth: 0	//# noDepthTracking!
		, depthLimit: limit || depthLimit	//# noDepthLimit!
		, documentDepth: 0	//# noDocumentDepthLimit!
		, documentDepthLimit: limit || documentDepthLimit	//# noDocumentDepthLimit!
		, ancestors: []	//# noCircularRefNotation!
		, path: []		//# noUniqueRefNotation!
		, refs: new WeakMap()	//# noUniqueRefNotation!
	} ;

	stringifyAnyType(
		v
		, runtime
		, propertyMask	//# noPropertyMask!
	) ;

	return runtime.str ;
}
943043
function () {
		var message = this.message;
		var name = this.name;
		var url = this.url;
		var result = name;
		if (message) {
			result +=  ': ' + message;
		}
		if (url) {
			result += ' (' + url + ')';
		}
		return result;
	}
351520
function stringify(input) {
				if (typeof input === 'string') {
					return input;
				}

				if (!input) {
					return '';
				}

				output = input.m;

				var variations = [];
				for (var key in input) {
					if (input.hasOwnProperty(key) && key !== 'm') {
						// Only show variations that are not the primary one, since
						// primary variations are chosen by default
						if (input[key] > 0) {
							if (verbose) {
								variations.push(', variation ' + input[key] + ' at move ' + key);
							} else {
								variations.push('-' + key + ':' + input[key]);
							}
						}
					}
				}

				output += variations.join('');
				return output;
			}
1325032
function CFG(rules) {
  let arr = [];

  arr.__proto__ = CFG.prototype;
  if (Array.isArray(rules)) {
    rules.forEach(arr.rule.bind(arr));
  }

  return arr;
}
581109
function apply_rule(name, gcase, rule) {
        var mod;
        if (gcase === 'nominative') mod = '.';
        else {
            for (var i = 0; i < predef.cases.length; i++) {
                if (gcase === predef.cases[i]) {
                    mod = rule.mods[i - 1];
                    break;
                }

            }
        }

        for (var i = 0; i < mod.length; i++) {
            var chr = mod[i];
            switch (chr) {
                case '.':
                    break;
                case '-':
                    name = name.substr(0, name.length - 1);
                    break;
                default:
                    name += chr;
            }
        }
        return name;
    }
704997
function createPrefixedRule(rule, prefix) {
  const prefixLength = prefix.length;
  const selectorStart = rule.selector.slice(1, prefixLength + 1);
  const isAlreadyPrefixed = selectorStart === prefix;
  if (isAlreadyPrefixed) return false;

  return rule.clone({
    selector: `.${prefix + rule.selector.substring(1)}`,
  });
}
616208
function stringify(str) {
            if (!str) {
                return str;
            }

            var newStr = '';
            for (var i = 0, l = str.length, ch; i < l; i++) {
                ch = str.charCodeAt(i);
                if (ch === 0) {
                    continue;
                }
                newStr += String.fromCharCode(ch);
            }
            return newStr;
        }
624254
function() {
    var value = [];

    if (typeof this.ruleValue === 'string') {
      value = this.ruleValue.split(',');
    }

    if (typeof this.ruleValue === 'number') {
      value.push(this.ruleValue);
    }

    if (this.ruleValue instanceof Array) {
      value = this.ruleValue;
    }

    return value;
  }
818484
function standardizeRule( rule ) {
		rule.elements = convertValidatorToHash( rule.elements, /\s+/ ) || null;
		rule.propertiesOnly = rule.propertiesOnly || ( rule.elements === true );

		var delim = /\s*,\s*/,
			i;

		for ( i in validators ) {
			rule[ i ] = convertValidatorToHash( rule[ i ], delim ) || null;
			rule[ validatorsRequired[ i ] ] = extractRequired( convertValidatorToHash(
				rule[ validatorsRequired[ i ] ], delim ), rule[ i ] ) || null;
		}

		rule.match = rule.match || null;
	}
959892
function rules() {
        $rules = $this->rules;
        array_walk($rules, function (&$v) {
            $v = implode('|', $v);
        });

        return $rules;
    }
1190082
function rulename() {
    var ret = this.seq(ALPHA, this.manyf(this.choicef(ALPHA, DIGIT, this.stringf('-'))));
    this.rules.last_def = this.rules.line;
    return [].concat(ret[1]).concat(ret[2]).join('');
}
531525
function createRules() {
  var rules = {};
  sets.forEach(function (set$$1) {
    set$$1.lngs.forEach(function (l) {
      rules[l] = {
        numbers: set$$1.nr,
        plurals: _rulesPluralsTypes[set$$1.fc]
      };
    });
  });
  return rules;
}
236256
function stringifyStyle(style) {
  if (typeof style === 'string') {
    return style;
  }
  var values = [];
  for (var key in style) {
    values.push(key + ':' + style[key]);
  }
  return values.join(';');
}
379725
function(stuff) {
      var len = this.str.length;
      if (typeof stuff == 'number') {
        this.str = this.str.substr(stuff);
      } else if (typeof stuff == 'string') {
        this.str = this.str.substr(stuff.length);
      } else if (stuff instanceof RegExp) {
        var m = this.str.match(stuff);
        if (m) {
          this.str = this.str.substr(m[0].length);
        }
      }
      return len > this.str.length;
    }
967121
function (rules) {
		if (!_.isArray(rules)) {
			rules = [ rules ];
		}

		var that = this;

		return _.map(rules, function (rule) {
			if (typeof rule === 'string') {
				return that._parseString(rule);
			}

			if (_.isPlainObject(rule)) {
				return that._parseObject(rule);
			}

			throw new Error('#V1: invalid rule type, must be string or plain object');
		});
	}