function ceiln( x, n ) {
	var s;
	var y;
	if (
		isnan( x ) ||
		isnan( n ) ||
		isInfinite( n )
	) {
		return NaN;
	}
	if (
		// Handle infinities...
		isInfinite( x ) ||

		// Handle +-0...
		x === 0.0 ||

		// If `n` exceeds the maximum number of feasible decimal places (such as with subnormal numbers), nothing to round...
		n < MIN_EXP_SUBNORMAL ||

		// If `|x|` is large enough, no decimals to round...
		( abs( x ) > MAX_INT && n <= 0 )
	) {
		return x;
	}
	// The maximum absolute double is ~1.8e308. Accordingly, any possible positive finite `x` rounded to the nearest >=10^309 is infinity and any negative finite `x` is zero.
	if ( n > MAX_EXP ) {
		if ( x <= 0.0 ) {
			return -0.0; // preserve the sign (same behavior as ceil)
		}
		return PINF;
	}
	// If we overflow, return `x`, as the number of digits to the right of the decimal is too small (i.e., `x` is too large / lacks sufficient fractional precision) for there to be any effect when rounding...
	if ( n < MIN_EXP ) {
		s = pow( 10.0, -(n + MAX_EXP) );
		y = (x*HUGE) * s; // order of operation matters!
		if ( isInfinite( y ) ) {
			return x;
		}
		return ( ceil(y)/HUGE ) / s;
	}
	s = pow( 10.0, -n );
	y = x * s;
	if ( isInfinite( y ) ) {
		return x;
	}
	return ceil( y ) / s;
}
Rounds a numeric value to the nearest multiple of \\(10^n\\) toward positive infinity.

## Method

1.  If \\(|x| <= 2^{53}\\) and \\(|n| <= 308\\), we can use the formula

    ```tex
    \operatorname{ceiln}(x,n) = \frac{\operatorname{ceil}(x \cdot 10^{-n})}{10^{-n}}
    ```

    which shifts the decimal to the nearest multiple of \\(10^n\\), performs a standard \\(\mathrm{ceil}\\) operation, and then shifts the decimal to its original position.

    <!-- <note> -->

    If \\(x \cdot 10^{-n}\\) overflows, \\(x\\) lacks a sufficient number of decimal digits to have any effect when rounding. Accordingly, the rounded value is \\(x\\).

    <!-- </note> -->

    <!-- <note> -->

    Note that rescaling \\(x\\) can result in unexpected behavior. For instance, the result of \\(\operatorname{ceiln}(0.2+0.1,-16)\\) is \\(0.3000000000000001\\) and not \\(0.3\\). While possibly unexpected, this is not a bug. The behavior stems from the fact that most decimal fractions cannot be exactly represented as floating-point numbers. And further, rescaling can lead to slightly different fractional values, which, in turn, affects the result of \\(\mathrm{ceil}\\).

    <!-- </note> -->

2.  If \\(n > 308\\), we recognize that the maximum absolute double-precision floating-point number is \\(\approx 1.8\mbox{e}308\\) and, thus, the result of rounding any possible positive finite number \\(x\\) to the nearest \\(10^n\\) is \\(\infty\\) and any possible negative finite number \\(x\\) is \\(-0\\). To ensure consistent behavior with \\(\operatorname{ceil}(x)\\), if \\(x < 0\\), the sign of \\(x\\) is preserved.

3.  If \\(n < -324\\), \\(n\\) exceeds the maximum number of possible decimal places (such as with subnormal numbers), and, thus, the rounded value is \\(x\\).

4.  If \\(x > 2^{53}\\), \\(x\\) is **always** an integer (i.e., \\(x\\) has no decimal digits). If \\(n <= 0\\), the rounded value is \\(x\\).

5.  If \\(n < -308\\), we let \\(m = n + 308\\) and modify the above formula to avoid overflow.

    ```tex
    \operatorname{ceiln}(x,n) = \frac{\biggl(\frac{\operatorname{ceil}( (x \cdot 10^{308}) 10^{-m})}{10^{308}}\biggr)}{10^{-m}}
    ```

    If overflow occurs, the rounded value is \\(x\\).

## Special Cases

```tex
\begin{align*}
\operatorname{ceiln}(\mathrm{NaN}, n) &= \mathrm{NaN} \\
\operatorname{ceiln}(x, \mathrm{NaN}) &= \mathrm{NaN} \\
\operatorname{ceiln}(x, \pm\infty) &= \mathrm{NaN} \\
\operatorname{ceiln}(\pm\infty, n) &= \pm\infty \\
\operatorname{ceiln}(\pm 0, n) &= \pm 0
\end{align*}
```

@param {number} x - input value
@param {integer} n - integer power of 10
@returns {number} rounded value

@example
// Round a value to 2 decimal places:
var v = ceiln( 3.141592653589793, -2 );
// returns 3.15

@example
// If n = 0, `ceiln` behaves like `ceil`:
var v = ceiln( 3.141592653589793, 0 );
// returns 4.0

@example
// Round a value to the nearest thousand:
var v = ceiln( 12368.0, 3 );
// returns 13000.0