/* With value class
769819
@SuppressWarnings("unchecked")
    public static <X, Y> Y getValue(X target, String propertyPath,
                                    Class<Y> valueClass) {
        return getExpression((Class<X>) target.getClass(), propertyPath,
                valueClass).getValue(target);
    }
743107
function(path, value, data , op, computed){
    var computed = this.computed,
      op = op || "=", prev, 
      computedProperty = computed? computed[path]:null;

    if(op !== '='){
      prev = computedProperty? computedProperty.get(this): data[path];
      switch(op){
        case "+=":
          value = prev + value;
          break;
        case "-=":
          value = prev - value;
          break;
        case "*=":
          value = prev * value;
          break;
        case "/=":
          value = prev / value;
          break;
        case "%=":
          value = prev % value;
          break;
      }
    }
    if(computedProperty) {
      if(computedProperty.set) return computedProperty.set(this, value);
    }
    data[path] = value;
    return value;
  }
234613
function setClass( $value, $params=FALSE ) {
    $this->class['value']  = $value;
    $this->class['params'] = $this->_setParams( $params );
  }
1212356
function(name, value) {
      var lcname = name.toLowerCase();
      if (typeof value === "string" &&
          lcname in this._designSet.param &&
          'multiValue' in this._designSet.param[lcname]) {
          value = [value];
      }
      this.jCal[PROP_INDEX][name] = value;
    }
80293
private void appendValue(StringBuilder builder, Class fieldClazz, Object value, boolean useToken)
    {
        // To allow handle byte array class object by converting it to string

        if (fieldClazz != null && fieldClazz.isAssignableFrom(byte[].class))
        {
            value = value != null ? value : ByteBufferUtil.EMPTY_BYTE_BUFFER.array();
            StringBuilder hexstr = new StringBuilder("0x");
            builder.append(hexstr.append((Hex.encodeHex((byte[]) value))));
        }
        else
        {
            if (useToken)
            {
                builder.append(TOKEN);
            }

            if (fieldClazz != null
                    && value != null
                    && (fieldClazz.isAssignableFrom(String.class) || isDate(fieldClazz)
                            || fieldClazz.isAssignableFrom(char.class) || fieldClazz.isAssignableFrom(Character.class) || value instanceof Enum))
            {

                if (fieldClazz.isAssignableFrom(String.class))
                {
                    // To allow escape character
                    value = ((String) value).replaceAll("'", "''");
                }
                builder.append("'");

                if (isDate(fieldClazz)) // For CQL, date has to
                                        // be in date.getTime()
                {
                    builder.append(PropertyAccessorFactory.getPropertyAccessor(fieldClazz).toString(value));
                }
                else if (value instanceof Enum)
                {
                    builder.append(((Enum) value).name());
                }

                else
                {
                    builder.append(value);
                }
                builder.append("'");
            }
            else
            {
                builder.append(value);
            }

        }
        if (useToken)
        {
            builder.append(CLOSE_BRACKET);
        }
    }
13160
function(name, property, value, types) {
  if (!(types instanceof Array)) {
    types = [types];
  }
  if (types.indexOf(typeof value) === -1) {
    debug('%s \'%s\' expected %j got: %j', name, property, types, value);
    throw new Error(name + ' \'' + property + '\' expected one of type(s): \'' +
                    types.join(',') + '\' got type: \'' + typeof value + '\'');
  }
}
1294511
def set_class_value(self, selector, classname):
        """"""
        return self.evaluate("""
            (function () {{
            var element = document.querySelector({0});
            element.className = {1};
            }})();""".format(repr(selector), repr(classname)))
1139904
private JsonElement toElement(final Object value) {

		if (value != null) {

			if (value instanceof String) {

				return new JsonPrimitive((String)value);

			} else if (value instanceof Number) {

				return new JsonPrimitive((Number)value);

			} else if (value instanceof Boolean) {

				return new JsonPrimitive((Boolean)value);

			} else if (value.getClass().isArray()) {

				final JsonArray arr   = new JsonArray();
				final Object[] values = (Object[])value;

				for (final Object v : values) {
					arr.add(toElement(v));
				}

				return arr;

			} else {

				return new JsonPrimitive(value.toString());
			}
		}

		return JsonNull.INSTANCE;
	}
1307434
function _prepareValue($value, $assoc)
    {
        if (null === $value) {
            return null;
        } elseif (!$assoc) {
            return $value;
        } else {
            $name = $this->getName();
            if (!strpos($name, '[')) {
                return array($name => $value);
            } else {
                $keys = str_replace(
                    array('\\', '\'', ']', '['), array('\\\\', '\\\'', '', "']['"),
                    $name
                );
                $keysArray = explode("']['", $keys);
                return HTML_QuickForm_utils::recursiveBuild($keysArray, $value);
            }
        }
    }
718547
function calcValueInfo(valueToken) {
    const text = valueToken.htmlValue
    const firstChar = text[0]
    const quote = firstChar === "'" || firstChar === '"' ? firstChar : undefined
    const content = quote ? text.slice(1, -1) : text
    return {
        quote,
        content,
    }
}
87306
function compileFormat (value) {
  var c = compiledCache[value];
  if (c) {
    return c;
  }

  var m;
  var lastIndex = 0;
  var v = [];
  var o = null;

  var REG = value.indexOf('{') === -1 ? PARAM : MUSH;

  while(m = REG.exec(value)){
    var index = m.index;

    if (lastIndex !== index) {
      v.push(value.slice(lastIndex, index));
    }
    if (parameters.hasOwnProperty(m[1])) {
      if (m[2]) {
        v.push({p: m[1], o: +m[2]});
      } else {
        v.push({p: m[1]});
      }
    } else {
      v.push(m[0]);
    }
    lastIndex = index + m[0].length;
  }
  if (lastIndex !== value.length) {
    var suf = value.slice(lastIndex);
    var sufIndex = suf.indexOf('>>');
    if (sufIndex === -1) {
      v.push(suf);
    } else {
      if (sufIndex !== 0) {
        v.push(suf.slice(0, sufIndex));
      }
      o = getOptions(suf.slice(sufIndex));
    }
  }
  REG.lastIndex = 0;

  c = o ? {v, o} : {v};
  compiledCache[value] = c;
  return c;
}
721503
function parseClass(params, constructor) {
        var key,
            value,
            saved = {};

        delete params.$locked;

        // Check and save constants to parse later
        if (hasOwn(params, '$constants')) {
            saved.$constants = params.$constants;
            delete params.$constants;
        }

        // Check and save finals to parse later
        if (hasOwn(params, '$finals')) {
            saved.$finals = params.$finals;
            delete params.$finals;
        }

        // Parse members
        parseMembers(params, constructor);

        // Parse constants
        if (saved.$constants) {
            for (key in saved.$constants) {
                value = saved.$constants[key];

                constructor[$class].staticProperties[key] = value;
                constructor[key] = value;
            }
        }

        // Parse finals
        if (saved.$finals) {
            parseMembers(saved.$finals, constructor, true);
        }
    }
1027025
function valueGetter({ attrs, attributeBlocks }) {
      let values = null;
      return function getValue(name) {
        if (!values) {
          values = new Map();
          // Look in &attributes(...) style attribute blocks for any known values.
          // eslint-disable-next-line no-unused-vars
          for (const attributeBlock of attributeBlocks) {
            const jsAst = parseExpression(attributeBlock.val);
            if (jsAst.type === 'ObjectExpression' && jsAst.properties) {
              for (const property of jsAst.properties) {
                if (property.type !== 'ObjectProperty' || property.method || property.computed) {
                  // Can't sanitize getters or methods, or spread elements.
                  continue;
                }
                const attrName = property.key.name || property.key.value;
                const { code: valueExpression } = generate(property.value);
                if (constantinople(valueExpression)) {
                  values.set(attrName, constantinople.toConstant(valueExpression));
                }
              }
            }
          }
          // Find any known values among the (attr=expr, ...) style attributes.
          for (const attr of attrs) {
            if (constantinople(attr.val)) {
              values.set(attr.name, constantinople.toConstant(attr.val));
            }
          }
        }

        name = String(name).toLowerCase();
        return values.get(name);
      };
    }
1277244
function consumeValue(stream) {
	const values = new CSSValue();
	let value;

	while (!stream.eof()) {
		// use colon as value separator
		stream.eat(COLON);
		if (value = consumeNumericValue(stream) || consumeColor(stream)) {
			// edge case: a dash after unit-less numeric value or color should
			// be treated as value separator, not negative sign
			if (!value.unit) {
				stream.eat(DASH);
			}
		} else {
			stream.eat(DASH);
			value = consumeKeyword(stream, true);
		}

		if (!value) {
			break;
		}

		values.add(value);
	}

	return values;
}
283744
function includes (data, value) {
    var iterator, iteration, keys, length, i;

    if (! assigned(data)) {
      return false;
    }

    if (haveSymbols && data[Symbol.iterator] && isFunction(data.values)) {
      iterator = data.values();

      do {
        iteration = iterator.next();

        if (iteration.value === value) {
          return true;
        }
      } while (! iteration.done);

      return false;
    }

    keys = Object.keys(data);
    length = keys.length;
    for (i = 0; i < length; ++i) {
      if (data[keys[i]] === value) {
        return true;
      }
    }

    return false;
  }
1181456
@Override
    public Query<S> withValues(Object... values) {
        if (values == null || values.length == 0) {
            return this;
        }
        throw error();
    }
154691
function endsWithString(endingValue, valueToTest) {
  const position = valueToTest.length - endingValue.length;
  const lastIndexOfValue = valueToTest.lastIndexOf(endingValue);

  return !!~lastIndexOfValue && lastIndexOfValue === position;
}