CONSTANT_EXPECTED_TYPE_MISMATCH      text ranges: [(68,69)]
      PSI: KtConstantExpression at (5,12-13)
  for PSI element of type KtNameReferenceExpression at (4,9-10)
    TYPE_MISMATCH      text ranges: [(54,55)]
      PSI: KtNameReferenceExpression at (4,9-10)
  for PSI element of type KtStringTemplateExpression at (1,14-16)
    TYPE_MISMATCH      text ranges: [(13,15)]
      PSI: KtStringTemplateExpression at (1,14-16)

 *   <dt>{@link ClassToInstanceMap}
 *   <dd>An extension of {@link java.util.Map} that associates a raw type with an instance of that
 *       type.
 * </dl>
 *
 * <h2>Ranges</h2>
 *
 * <ul>
 *   <li>{@link Range}
 *   <li>{@link RangeMap}
 *   <li>{@link RangeSet}
 *   <li>{@link DiscreteDomain}
 *   <li>{@link ContiguousSet}
 * </ul>
 *
 * <h2>Classes of static utility methods</h2>
 *
 * <ul>

 *   <dt>{@link ClassToInstanceMap}
 *   <dd>An extension of {@link java.util.Map} that associates a raw type with an instance of that
 *       type.
 * </dl>
 *
 * <h2>Ranges</h2>
 *
 * <ul>
 *   <li>{@link Range}
 *   <li>{@link RangeMap}
 *   <li>{@link RangeSet}
 *   <li>{@link DiscreteDomain}
 *   <li>{@link ContiguousSet}
 * </ul>
 *
 * <h2>Classes of static utility methods</h2>
 *
 * <ul>

		}
	}

	return out
}

// UnifyRanges merges the ranges from 'c' into the list of ranges for 's'.
func (s *Scope) UnifyRanges(c *Scope) {
	s.Ranges = MergeRanges(s.Ranges, c.Ranges)
}

// AppendRange adds r to s, if r is non-empty.
// If possible, it extends the last Range in s.Ranges; if not, it creates a new one.
func (s *Scope) AppendRange(r Range) {
	if r.End <= r.Start {
		return
	}
	i := len(s.Ranges)

// IsOneOf reports whether the rune is a member of one of the ranges.
// The function "In" provides a nicer signature and should be used in preference to IsOneOf.
func IsOneOf(ranges []*RangeTable, r rune) bool {
	for _, inside := range ranges {
		if Is(inside, r) {
			return true
		}
	}
	return false
}

// In reports whether the rune is a member of one of the ranges.
func In(r rune, ranges ...*RangeTable) bool {
	for _, inside := range ranges {

Diagnostics from elements:
  for PSI element of type KtStringTemplateExpression at (10,19-42)
    ERROR_SUPPRESSION      text ranges: [(198,221)]
      PSI: KtStringTemplateExpression at (10,19-42)
  for PSI element of type KtStringTemplateExpression at (5,19-42)
    ERROR_SUPPRESSION      text ranges: [(78,101)]

			},
			wantErr: false,
		},
		{
			test: "config below normal ranges, error",
			config: imagePolicyWebhookConfig{
				AllowTTL:     minAllowTTL - time.Duration(1),
				DenyTTL:      minDenyTTL - time.Duration(1),
				RetryBackoff: minRetryBackoff - time.Duration(1),
			},
			wantErr: true,
		},
		{
			test: "config above normal ranges, error",
			config: imagePolicyWebhookConfig{

    ARGUMENT_TYPE_MISMATCH      text ranges: [(54,55)]
      PSI: KtNameReferenceExpression at (4,9-10)
  for PSI element of type KtProperty at (1,1-16)
    INITIALIZER_TYPE_MISMATCH      text ranges: [(13,15)]
      PSI: KtProperty at (1,1-16)
  for PSI element of type KtConstantExpression at (5,12-13)
    RETURN_TYPE_MISMATCH      text ranges: [(68,69)]

  values.insert(values.end(), range.begin(), range.end());
  Append(values, ranges...);
}

// Returns the number of elements in `range`.
template <typename Range>
size_t Size(Range&& range) {
  return range.size();
}

// Returns the total number of elements in a variadic number of `ranges`.
template <typename Range, typename... RangeTs>
size_t Size(Range&& range, RangeTs&&... ranges) {

        function zoomFunction(plot, reset) {
            reset = reset || false;
            return function (event, ranges) {
                $.each(plot.getXAxes(), function(_, axis) {
                    const opts = axis.options;
                    opts.min = reset ? null : ranges.xaxis.from;
                    opts.max = reset ? null : ranges.xaxis.to;
                });
                $.each(plot.getYAxes(), function(_, axis) {