<?php
/**
 * Shared options-engine pricing helpers.
 *
 * Loaded by engine.php alongside swatches. price_to_display is called from the
 * storefront, the cart, the product class and the add-to-cart template, so it
 * belongs in the engine itself rather than in any optional module.
 */

defined( 'ABSPATH' ) || exit;

/**
 * Money rounded to the store's decimals the way the arithmetic meant it.
 *
 * A price worked out in floating point lands a hair either side of the
 * figure it means: 1.30 x 0.95 is 1.2349999999999999, meant 1.235. PHP's
 * round() up to 8.3 settled that hair first (at 15 significant digits) and
 * took the meant half away from zero, 1.24. PHP 8.4 rounds the hair itself,
 * 1.23, so the same choice would charge a penny less on a newer server.
 * This settles the hair the same way on every PHP. The page rounds with
 * bbMoneyRound, which settles the same hair, so the price the page quotes
 * is the price the basket charges. BundleBoss carries the same rule as
 * bundle_boss_round_money().
 *
 * @param float|int|string $amount   The amount.
 * @param int|null         $decimals Places to round to; the store's price decimals when null.
 * @return float
 */
function addon_boss_round_money( $amount, ?int $decimals = null ): float {
	$amount   = (float) $amount;
	$decimals = null === $decimals ? wc_get_price_decimals() : $decimals;
	if ( 0.0 === $amount || ! is_finite( $amount ) ) {
		return $amount;
	}
	$settle = 14 - (int) floor( log10( abs( $amount ) ) );
	if ( $settle > $decimals ) {
		$amount = round( $amount, $settle );
	}
	return round( $amount, $decimals );
}

/**
 * The amount to *display* for a bundle-side price, in the store's chosen tax
 * basis (the "Display prices in the shop" setting). This is display only:
 * charging never reads it - the cart engine prices the line from the raw
 * component prices (see addon_boss_set_cart_item_price) and WooCommerce
 * applies tax there. It mirrors what WC_Product::get_price_html() does for a
 * normal product, so a bundle's shown price reads in the same incl/excl-tax
 * basis as the rest of the catalogue instead of the raw stored figure.
 *
 * $ref is the product whose tax status/class applies: the component product
 * for an item price, the bundle itself for a box-size or whole-bundle price.
 * With taxes off (or a non-taxable product) WooCommerce returns the figure
 * unchanged, so this is a no-op on stores that do not charge tax.
 *
 * @param WC_Product $ref The product whose tax status/class governs the price.
 * @param float      $raw The raw stored price.
 * @return float The price to display, in the shop's tax basis.
 */
function addon_boss_price_to_display( WC_Product $ref, float $raw, string $context = 'shop' ): float {
	if ( $raw <= 0 ) {
		return 0.0;
	}
	// WooCommerce has TWO display settings - "in the shop" and "during cart and
	// checkout" - and a store may set them differently, so the caller says which
	// one applies. Core reads the right option itself: 'cart' picks
	// woocommerce_tax_display_cart, anything else woocommerce_tax_display_shop.
	// We require WC 8.0 and display_context landed in 7.6, so it is always there.
	return (float) wc_get_price_to_display(
		$ref,
		array(
			'price'           => $raw,
			'qty'             => 1,
			'display_context' => $context,
		)
	);
}

/**
 * A printed fee in the shopper's basis, or unchanged when there is nothing to
 * convert it against.
 *
 * The label beside an add-on and the suffix in the cart are the SAME money and
 * must read the same. The cart side has always had the product and converted;
 * the label had neither, so a shop running a VAT display toggle printed the
 * raw stored figure on the product page and the converted one in the tray.
 *
 * Null product means a caller that genuinely has none (a repeat instance
 * rendered outside a product context), and there is no honest conversion to
 * make: the raw figure is returned exactly as it was printed before, so this
 * can never change what a caller without a product shows.
 *
 * @param float $fee     The raw stored fee.
 * @param mixed $product The product it is charged against, or null.
 * @return float The figure to print.
 */
function addon_boss_fee_shown( float $fee, $product = null ): float {
	if ( $fee <= 0 || ! $product instanceof WC_Product ) {
		return $fee;
	}
	return addon_boss_price_to_display( $product, $fee );
}

/**
 * A figure in the ENTRY basis, converted to the basis a shopper is reading.
 *
 * The name-your-price field speaks the shopper's basis end to end, and on a
 * shop with a tax toggle that basis is whatever the toggle says, which the
 * server cannot read from any option: the toggle plugin keeps its state in
 * the browser. So the field POSTS the basis it was speaking, and this pair of
 * helpers converts bounds out to it and the typed amount back from it. The
 * declared basis is money-safe to trust: bounds and charge convert together,
 * so whatever basis is claimed, the shopper pays the figure they saw against
 * the bounds they saw.
 */
function addon_boss_entry_to_basis( float $entry, $product, string $basis ): float {
	if ( $entry <= 0 || ! $product instanceof WC_Product ) {
		return $entry;
	}
	return 'incl' === $basis
		? (float) wc_get_price_including_tax( $product, array( 'price' => $entry, 'qty' => 1 ) )
		: (float) wc_get_price_excluding_tax( $product, array( 'price' => $entry, 'qty' => 1 ) );
}

/**
 * The inverse: a figure TYPED in the given basis, back to the entry basis so
 * it can ride the fee pipeline like every configured charge.
 */
function addon_boss_basis_to_entry( float $shown, $product, string $basis ): float {
	if ( $shown <= 0 || ! $product instanceof WC_Product ) {
		return $shown;
	}
	// A big round figure, so the ratio survives core's per-call rounding.
	$bb_ratio = addon_boss_entry_to_basis( 1000.0, $product, $basis ) / 1000.0;
	return $bb_ratio > 0 ? $shown / $bb_ratio : $shown;
}

/**
 * The ONE way this plugin prints a figure a shopper will read.
 *
 * Every storefront surface used to format its own money: the receipt, the grid,
 * the discount cards, the position tiles, the choice labels, the date bands.
 * Each converted the display basis itself, or forgot to, so a shop running a
 * VAT toggle got a different answer per surface and every report of it closed
 * exactly one of them. The dropdown promised "+£9.00" while the tray beneath it
 * charged £10.80, and fixing the tray never reached the dropdown.
 *
 * Converting and formatting therefore live together, once, here. Callers say
 * what they are printing, not how to print it.
 *
 * `convert => false` is for an amount ALREADY in the display basis (a figure a
 * caller converted itself, or one read back from a data attribute this plugin
 * wrote). It is not an escape hatch for "no product to hand": pass the product
 * and let the guard in addon_boss_fee_shown() decide.
 *
 * `plain => true` is for a context that cannot hold markup: an <option>, an
 * attribute, a cart or order string. Such a figure cannot carry a VAT toggle's
 * dual-basis pair, so the storefront script repaints it from data-delta when
 * the shopper switches. See bbSyncChoiceFees().
 *
 * @param float $amount  The figure, raw unless convert is false.
 * @param mixed $product The product it is charged against, or null.
 * @param array $args    plain, sign, context ('shop'|'cart'), convert.
 * @return string The figure as a shopper should read it.
 */
/**
 * The product the surface being rendered belongs to.
 *
 * A field type registers a render callback of a FIXED shape - definition, name,
 * value, id, attributes - with no product in it, so the date field, and every
 * field type added after it, had no way to convert what it printed even though
 * its caller knew the product perfectly well. Threading a sixth argument
 * through every callback would fix the ones that exist today and miss the next
 * one written, which is the whole reason this class of bug kept coming back.
 *
 * So the panel says once whose money it is about to print, and addon_boss_money()
 * falls back to it. An explicitly passed product always wins; this is only for
 * the callers that structurally cannot have one.
 *
 * Set it with the product, restore it with the value returned, always in pairs.
 *
 * @param mixed $set A product to make current, or false to read without setting.
 * @return mixed The product that was current before this call.
 */
function addon_boss_money_product( $set = false ) {
	static $current = null;
	$was             = $current;
	if ( false !== $set ) {
		$current = $set instanceof WC_Product ? $set : null;
	}
	return $was;
}

function addon_boss_money( float $amount, $product = null, array $args = array() ): string {
	if ( ! $product instanceof WC_Product ) {
		$product = addon_boss_money_product();
	}
	$args = array_merge(
		array(
			'plain'   => false,
			'sign'    => false,
			'context' => 'shop',
			'convert' => true,
		),
		$args
	);
	$size  = abs( $amount );
	// No product is a caller that genuinely has none, and there is no honest
	// conversion to make: the figure prints exactly as it did before.
	$shown = ( $args['convert'] && $product instanceof WC_Product )
		? addon_boss_price_to_display( $product, $size, (string) $args['context'] )
		: $size;
	$sign = '';
	if ( $args['sign'] && 0.0 !== (float) $amount ) {
		$sign = $amount < 0 ? '-' : '+';
	} elseif ( $amount < 0 ) {
		$sign = '-'; // a reduction reads as one even where no sign was asked for.
	}
	// addon_boss_plain_price() is the text twin of wc_price(): same decimals,
	// same separators, same symbol position, no markup.
	return $sign . ( $args['plain'] ? addon_boss_plain_price( $shown ) : wc_price( $shown ) );
}

/**
 * The one rounding rule every money figure this plugin prints in a browser
 * must obey, emitted as JavaScript.
 *
 * `toFixed` does not round. It truncates whatever the float actually holds,
 * and a unit price assembled from separate multiplications (a garment at its
 * band, then its printing at the same band) lands on 21.854999999999997. So
 * `toFixed( 2 )` prints 21.85: a penny under the figure the merchant works
 * out by hand, and a penny under the very row the SERVER printed before a
 * script repainted it, which means the page disagrees with itself as well as
 * with them. A founding customer read that off his own order, 7 Sept 2026.
 *
 * Two steps, and neither alone is enough. `toPrecision` clears the dust that
 * made 21.855 arrive short. The exponent shift then moves the decimal point
 * without putting the dust back, which multiplying cannot do: `9.405 * 100`
 * is `940.4999999999999` all over again.
 *
 * Emitted rather than shared as a file for the same reason as the formatter
 * below: these are inline blocks with no build step and no load order between
 * them. The assignment is guarded, so whichever block runs first defines it
 * and the rest find it already there.
 *
 * @return string JavaScript source, safe at the top of any block.
 */
function addon_boss_money_round_js(): string {
	return 'window.bbMoneyRound = window.bbMoneyRound || function ( v, dec ) {'
		. 'v = Number( v ); dec = Number( dec );'
		// A figure that is not a number cannot be a price, and a decimals
		// setting that is not one is nobody's setting: fall back to two.
		. 'if ( ! isFinite( v ) ) { return 0; }'
		. 'if ( ! isFinite( dec ) || dec < 0 || dec > 10 ) { dec = 2; }'
		. 'var neg = v < 0, a = Math.abs( v ), s = a.toPrecision( 12 );'
		// Past this magnitude toPrecision returns exponent notation, which the
		// shift below cannot parse. Nothing that large is a price: leave it be
		// rather than mangle it into one.
		. 'if ( s.indexOf( "e" ) > -1 ) { return v; }'
		. 'a = Number( Math.round( Number( Number( s ) + "e" + dec ) ) + "e-" + dec );'
		. 'return neg ? -a : a;'
		. '};'
		// A shown price, put back on the penny it was entered at and returned
		// in the shown basis with its fraction. See addon_boss_tax_factor().
		. 'window.bbTaxExact = window.bbTaxExact || function ( v, k, dec ) {'
		. 'v = Number( v ); k = Number( k );'
		. 'if ( ! isFinite( v ) || ! isFinite( k ) || k <= 0 || 1 === k ) { return isFinite( v ) ? v : 0; }'
		. 'return window.bbMoneyRound( v / k, dec ) * k;'
		. '};'
		// A figure baked in one tax basis, shown in the other: the VAT toggle's
		// arithmetic, in one place. The grid, the quantity discounts and the
		// measured size line each answer the toggle; three copies of the same
		// multiply drifted once already (the size line answered nobody, 14 Oct),
		// so the rule is emitted here and the blocks call it. Same basis, no
		// rate, or nothing to convert: the figure comes back untouched.
		. 'window.bbTaxFlip = window.bbTaxFlip || function ( v, rate, bakedIncl, showIncl ) {'
		. 'v = Number( v ); rate = Number( rate );'
		. 'if ( ! isFinite( v ) ) { return 0; }'
		. 'if ( ! isFinite( rate ) || rate <= 0 || !! bakedIncl === !! showIncl ) { return v; }'
		. 'var f = 1 + rate / 100;'
		. 'return bakedIncl ? v / f : v * f;'
		. '};';
}

/**
 * How a shown price relates to an entered one for this product: 1.2 where
 * prices are entered without a 20% tax and shown with it, 1 where the two
 * bases are the same.
 *
 * A page that multiplies a SHOWN unit price disagrees with the basket in a
 * shop whose two bases differ. WooCommerce rounds the shown price of one
 * (13.34 shows as 16.01) and the basket taxes the line (four are 53.36, plus
 * 20%, 64.03, not four times 16.01). Dividing a shown price by this factor
 * and rounding lands back on the entered penny; multiplying by it again gives
 * the shown price with its fraction, and a line built from that is the
 * basket's line.
 *
 * Taken from a large amount so it is the rate itself. The ratio of two real
 * prices carries the rounding of one of them: 16.01 over 13.34 is 1.20015.
 *
 * @param mixed $product The product whose tax status and class apply.
 * @return float The factor, 1.0 when it cannot be known.
 */
function addon_boss_tax_factor( $product ): float {
	if ( ! $product instanceof WC_Product || ! function_exists( 'wc_get_price_to_display' ) ) {
		return 1.0;
	}
	$shown = (float) wc_get_price_to_display( $product, array( 'price' => 1000000, 'qty' => 1 ) );
	return $shown > 0 ? $shown / 1000000 : 1.0;
}

/**
 * A variation's own factor, handed to the page with its variation data
 * wherever it differs from its product's.
 *
 * Every fee on a variable product's page is printed at the PRODUCT's tax
 * rate, and the basket taxes each line at its VARIATION's. A zero-rated Kids
 * variation at £10 with a £5 print read £16 on the page and £15 in the
 * basket; a standard-rated variation under a zero-rated product read less
 * than the basket took. Both pages read this to price the fees at the
 * variation's own rate: the one-at-a-time page for the chosen variation, the
 * grid for each line.
 *
 * Only where the two differ, so a product whose variations share its tax
 * class gets exactly the data it always had.
 *
 * @param mixed $data      The variation data WooCommerce hands the page.
 * @param mixed $product   The variable product.
 * @param mixed $variation The variation.
 * @return mixed The data, with bb_k where the variation's rate is its own.
 */
function addon_boss_variation_tax_factor( $data, $product, $variation ) {
	if ( ! is_array( $data ) || ! $product instanceof WC_Product || ! $variation instanceof WC_Product ) {
		return $data;
	}
	$own = addon_boss_tax_factor( $variation );
	if ( abs( $own - addon_boss_tax_factor( $product ) ) > 0.0000001 ) {
		$data['bb_k'] = $own;
	}
	// Its rate, for a VAT toggle's other side, whenever it is not the
	// product's: the page converts the shown figure with the product's rate
	// otherwise, and a zero-rated Kids size read £18.00 with VAT where the
	// basket charged £15.00. Not tied to the factor above: a shop that enters
	// and shows prices in one basis (both without VAT, or both with it) has a
	// factor of 1 on every line, and its toggle still has to know the rate.
	if ( wc_tax_enabled() ) {
		$rate = addon_boss_base_rate_of( $variation );
		if ( abs( $rate - addon_boss_base_rate_of( $product ) ) > 0.0000001 ) {
			$data['bb_rate'] = $rate;
		}
	}
	return $data;
}
add_filter( 'woocommerce_available_variation', 'addon_boss_variation_tax_factor', 10, 3 );

/**
 * The shop's base tax rate for a product's own tax class, in percent: the rate
 * a VAT toggle's other side is worked out with. 0 for a product that is not
 * taxable.
 *
 * @param mixed $product The product or variation.
 */
function addon_boss_base_rate_of( $product ): float {
	if ( ! $product instanceof WC_Product || ! class_exists( 'WC_Tax' ) || 'taxable' !== $product->get_tax_status() ) {
		return 0.0;
	}
	return (float) array_sum( array_map( 'floatval', array_column( WC_Tax::get_base_tax_rates( $product->get_tax_class() ), 'rate' ) ) );
}

/**
 * A JavaScript money formatter, baked with this shop's own format.
 *
 * The admin editors each grew their own one-liner - `sym + n.toFixed( 2 )` -
 * which is wrong in three ways at once for anyone outside a two-decimal,
 * dot-decimal, symbol-left shop: a zero-decimal currency (JPY, HUF, SEK, ISK)
 * gets back two decimals it turned off, the separators are never read, and the
 * symbol is nailed to the left. A merchant previewing their own discount bands
 * then reads a figure their own storefront would never print.
 *
 * Emitted rather than shared as a file because these editors are inline script
 * blocks with no build step between them; one generator keeps the recipe in a
 * single place even so. Same rule as bbFmt on the storefront: test for ABSENCE,
 * never falsiness, or the `||` default overrules exactly the merchants who
 * chose the falsy value.
 *
 * @param string $fn The function name to declare.
 * @return string JavaScript source declaring that function.
 */
function addon_boss_admin_money_js( string $fn ): string {
	$cfg = wp_json_encode(
		array(
			'dec' => (int) wc_get_price_decimals(),
			'ds'  => (string) wc_get_price_decimal_separator(),
			'ts'  => (string) wc_get_price_thousand_separator(),
			'sym' => html_entity_decode( get_woocommerce_currency_symbol() ),
			'pos' => (string) get_option( 'woocommerce_currency_pos', 'left' ),
		)
	);
	return 'var ' . $fn . 'Cfg = ' . $cfg . ';'
		. 'function ' . $fn . '( n ) {'
		. addon_boss_money_round_js()
		. 'var c = ' . $fn . 'Cfg, v = isFinite( n ) ? n : 0, neg = v < 0;'
		. 'var s = Math.abs( window.bbMoneyRound( v, c.dec ) ).toFixed( c.dec ), p = s.split( "." );'
		. 'p[ 0 ] = p[ 0 ].replace( /\B(?=(\d{3})+(?!\d))/g, c.ts );'
		. 's = p.join( c.ds );'
		. 'var out;'
		. 'switch ( c.pos ) {'
		. 'case "right": out = s + c.sym; break;'
		. 'case "left_space": out = c.sym + " " + s; break;'
		. 'case "right_space": out = s + " " + c.sym; break;'
		. 'default: out = c.sym + s;'
		. '}'
		. 'return ( neg ? "-" : "" ) + out;'
		. '}';
}

/**
 * An amount a merchant typed or pasted into an editor, read the way they
 * meant it: the plain decimal WooCommerce stores ("19.50"), or '' when it
 * holds no number at all.
 *
 * WooCommerce's own reader keeps the shop's decimal mark and drops every
 * other, so in a shop that writes 19.50 a pasted "19,50" became 1950: a
 * price list from a spreadsheet set up in Europe filled a grid at a hundred
 * times its prices with no word said (print shop tester, 18 Oct 2026). In
 * such a shop a comma is read for what it can be:
 *   - a thousands mark where the figure is grouped in threes ("1,950",
 *     "12,500,000"), or where a point follows it ("1,234.50");
 *   - else the decimal mark ("19,50", "19,5", "1.234,50", "0,950").
 * A shop that writes its decimals with a comma reads as WooCommerce reads.
 * The browser reads the same way through addon_boss_typed_amount_js().
 *
 * @param mixed $text What was typed or pasted.
 */
function addon_boss_typed_amount( $text ): string {
	$s = trim( (string) $text );
	if ( '' === $s ) {
		return '';
	}
	if ( ',' !== wc_get_price_decimal_separator() ) {
		$c  = (string) preg_replace( '/[^0-9.,\-]/', '', $s );
		$lc = strrpos( $c, ',' );
		if ( false !== $lc && false === strpos( $c, '.', $lc ) && ! preg_match( '/^-?[1-9]\d{0,2}(,\d{3})+$/', $c ) ) {
			$s = str_replace( array( '.', ',' ), '', substr( $c, 0, $lc ) ) . '.' . substr( $c, $lc + 1 );
		}
	}
	return (string) wc_format_decimal( $s );
}

/**
 * addon_boss_typed_amount() for the editors' scripts: window.bbTypedAmount(
 * text, ds ), where ds is the shop's decimal mark. Guarded, so whichever
 * block runs first defines it. tests/js/typed-amount-agrees-with-php.js runs
 * it against the PHP reader's own cases.
 *
 * @return string JavaScript source, safe at the top of any block.
 */
function addon_boss_typed_amount_js(): string {
	return <<<'JS'
	window.bbTypedAmount = window.bbTypedAmount || function ( text, ds ) {
		var s = String( null == text ? '' : text ).replace( /^\s+|\s+$/g, '' );
		if ( '' === s ) { return ''; }
		ds = null == ds ? '.' : String( ds );
		if ( ',' !== ds ) {
			var c  = s.replace( /[^0-9.,\-]/g, '' );
			var lc = c.lastIndexOf( ',' );
			if ( lc > -1 && -1 === c.indexOf( '.', lc ) && ! /^-?[1-9]\d{0,2}(,\d{3})+$/.test( c ) ) {
				s = c.slice( 0, lc ).replace( /[.,]/g, '' ) + '.' + c.slice( lc + 1 );
			}
		}
		// Then as wc_format_decimal(): the shop's mark as a point, the last
		// point kept, every other mark gone.
		if ( '' !== ds && '.' !== ds ) { s = s.split( ds ).join( '.' ); }
		return s.replace( /\.(?![^.]+$)|[^0-9.\-]/g, '' );
	};
JS;
}

/**
 * Which plural form the loaded translation picks for each count, as a string
 * of digits: the form for 0 to 199. A script that fills a count in (the price
 * table's "4 rows", a product's "1 offered") reads its form from here, so a
 * Polish "2 wiersze" and "5 wierszy" are as right in the script as _n() makes
 * them in PHP. Every rule a shipped language uses turns on the count itself
 * below 200 and on its last two digits above, so 200 places cover every count
 * (bbPlural maps 1234 to 134).
 */
function addon_boss_plural_index(): string {
	static $memo = array();
	$t       = get_translations_for_domain( 'addon-boss' );
	$expr    = 'n != 1';
	// Read, not isset(): WordPress 6.5's translations object serves its
	// headers through __get, which isset() never asks.
	$headers = is_object( $t ) ? $t->headers : array();
	$headers = is_array( $headers ) ? $headers : array();
	foreach ( $headers as $name => $value ) {
		if ( 'plural-forms' === strtolower( (string) $name ) && preg_match( '/plural\s*=\s*(.+)$/', (string) $value, $m ) ) {
			$expr = rtrim( trim( $m[1] ), ';' );
		}
	}
	if ( isset( $memo[ $expr ] ) ) {
		return $memo[ $expr ];
	}
	if ( ! class_exists( 'Plural_Forms' ) ) {
		require_once ABSPATH . WPINC . '/pomo/plural-forms.php';
	}
	$out = '';
	try {
		$rule = new Plural_Forms( $expr );
		for ( $n = 0; $n < 200; $n++ ) {
			$out .= (string) min( 9, max( 0, (int) $rule->get( $n ) ) );
		}
	} catch ( Exception $e ) {
		$out = '';
	}
	if ( 200 !== strlen( $out ) ) {
		$out = '1' . '0' . str_repeat( '1', 198 );
	}
	$memo[ $expr ] = $out;
	return $out;
}

/**
 * A count's sentence for a script, in every plural form the language has.
 *
 * $say is a closure around the literal _n() call, so the strings stay where
 * the translation tools find them: static fn( $n ) => _n( '%d row', '%d rows',
 * $n, 'addon-boss' ). It is asked once per form, with a count that takes that
 * form, and the script picks with window.bbPlural( forms, count ).
 *
 * @param callable $say Returns the sentence for a count.
 * @return array{f:array<int,string>,i:string}
 */
function addon_boss_js_plural( callable $say ): array {
	$index = addon_boss_plural_index();
	$forms = array();
	for ( $n = 0; $n < 200; $n++ ) {
		$k = (int) $index[ $n ];
		if ( ! isset( $forms[ $k ] ) ) {
			$forms[ $k ] = (string) $say( $n );
		}
	}
	$list = array();
	for ( $k = 0, $top = max( array_keys( $forms ) ); $k <= $top; $k++ ) {
		$list[] = $forms[ $k ] ?? (string) end( $forms );
	}
	return array(
		'f' => $list,
		'i' => $index,
	);
}

/**
 * The script's twin of _n() for addon_boss_js_plural()'s forms.
 *
 * @return string JavaScript source, safe at the top of any block.
 */
function addon_boss_plural_js(): string {
	return <<<'JS'
	window.bbPlural = window.bbPlural || function ( p, n ) {
		n = Math.abs( Math.round( Number( n ) ) ) || 0;
		if ( ! p || ! p.f || ! p.f.length ) { return ''; }
		var k = parseInt( String( p.i || '' ).charAt( n < 200 ? n : 100 + n % 100 ), 10 );
		return p.f[ isNaN( k ) ? p.f.length - 1 : Math.min( k, p.f.length - 1 ) ];
	};
JS;
}

/**
 * A product's base price to CHARGE, in base currency. When a currency switcher
 * is converting (active currency differs from the store base), read the raw
 * edit-context price so the sum is one clean base figure the switcher converts
 * exactly once. With nothing converting, active equals base and this is exactly
 * get_price(), so sales, tax and role pricing are untouched. Shared by the
 * standalone options price path and the bundle component sum, so both follow one
 * currency rule.
 */
function addon_boss_base_price( WC_Product $product ): float {
	if ( get_option( 'woocommerce_currency' ) !== get_woocommerce_currency() ) {
		return (float) $product->get_price( 'edit' );
	}
	return (float) $product->get_price();
}