@just-web/toolkits 3.0.0 → 3.1.0

package/src/units/convert-css-unit.ts

@@ -0,0 +1,292 @@
+import type { Required } from 'type-plus'
+import type { ConvertCssUnitOptions, CssLengthUnit } from './css-unit-converter.types.ts'
+import { getRemToPxScale } from './get-rem-to-px-scale.ts'
+import { parseCssValue } from './parse-css-value.ts'
+
+const PX_PER_IN = 96
+const PT_PER_IN = 72
+const PC_PER_IN = 6
+const CM_PER_IN = 2.54
+const MM_PER_IN = 25.4
+
+const DEFAULT_ELEMENT_FONT_SIZE = 16
+const DEFAULT_PRECISION = 4
+
+const ABSOLUTE_UNITS: CssLengthUnit[] = ['px', 'pt', 'pc', 'in', 'cm', 'mm']
+const LINE_UNITS: CssLengthUnit[] = ['lh', 'rlh']
+
+/**
+ * Converts a CSS length value from one unit to another.
+ *
+ * @param value - The value to convert. Can be a number or string (e.g. '16px', '1.5rem'). Pass-through for null/undefined.
+ * @param toUnit - The target unit.
+ * @param options - Conversion context. When omitted, uses browser auto-detect for rootFontSize and viewport when available.
+ * @returns The converted numeric value, or null/undefined when input is null/undefined.
+ * @throws When required context is missing (viewport, lineHeight, percentReference) or percentReference is 0 for % conversion.
+ *
+ * @example
+ * ```ts
+ * convertCssUnit('16px', 'rem')                    // 1
+ * convertCssUnit('1rem', 'px')                      // 16
+ * convertCssUnit('50%', 'px', { percentReference: 200 })  // 100
+ * convertCssUnit('10vw', 'px', { viewportWidth: 375 })    // 37.5
+ * ```
+ */
+export function convertCssUnit(
+	value: number | string | null | undefined,
+	toUnit: CssLengthUnit,
+	options?: ConvertCssUnitOptions | undefined
+): number | null | undefined {
+	const [num, parsedUnit] = parseCssValue(value)
+	if (num === null || num === undefined) return num
+	if (Number.isNaN(num)) {
+		throw new Error(`Invalid CSS value: ${value}`)
+	}
+
+	const fromUnit: CssLengthUnit = options?.fromUnit ?? normalizeUnit(parsedUnit) ?? 'px'
+
+	const resolved = resolveOptions(options)
+
+	if (fromUnit === toUnit) {
+		return Number(num.toFixed(resolved.precision))
+	}
+
+	let result: number
+
+	if (fromUnit === 'rem' && toUnit === 'em') {
+		result = remToEmDirect(num, resolved)
+	} else if (fromUnit === 'em' && toUnit === 'rem') {
+		result = emToRemDirect(num, resolved)
+	} else {
+		const px = valueToPx(num, fromUnit, resolved)
+		result = pxToValue(px, toUnit, resolved)
+	}
+
+	return Number(result.toFixed(resolved.precision))
+}
+
+function normalizeUnit(unit: string | undefined): CssLengthUnit | undefined {
+	if (!unit) return undefined
+	const u = unit.toLowerCase()
+	if (
+		u === 'px' ||
+		u === 'pt' ||
+		u === 'pc' ||
+		u === 'in' ||
+		u === 'cm' ||
+		u === 'mm' ||
+		u === 'rem' ||
+		u === 'em' ||
+		u === 'vw' ||
+		u === 'vh' ||
+		u === 'vmin' ||
+		u === 'vmax' ||
+		u === 'lh' ||
+		u === 'rlh' ||
+		u === 'ch' ||
+		u === '%'
+	) {
+		return u as CssLengthUnit
+	}
+	return undefined
+}
+
+function resolveOptions(
+	options?: ConvertCssUnitOptions | undefined
+): Required<
+	Pick<
+		ConvertCssUnitOptions,
+		| 'rootFontSize'
+		| 'elementFontSize'
+		| 'viewportWidth'
+		| 'viewportHeight'
+		| 'lineHeight'
+		| 'chWidth'
+		| 'percentReference'
+		| 'precision'
+	>
+> {
+	const rootFontSize = options?.rootFontSize ?? getRemToPxScale()
+	const elementFontSize = options?.elementFontSize ?? DEFAULT_ELEMENT_FONT_SIZE
+	const precision = options?.precision ?? DEFAULT_PRECISION
+
+	let viewportWidth = options?.viewportWidth
+	let viewportHeight = options?.viewportHeight
+	if (typeof window !== 'undefined') {
+		viewportWidth ??= window.innerWidth
+		viewportHeight ??= window.innerHeight
+	}
+
+	const lineHeight = options?.lineHeight
+	const chWidth = options?.chWidth ?? elementFontSize * 0.5
+	const percentReference = options?.percentReference ?? 0
+
+	return {
+		rootFontSize,
+		elementFontSize,
+		viewportWidth: viewportWidth ?? 0,
+		viewportHeight: viewportHeight ?? 0,
+		lineHeight: lineHeight ?? 0,
+		chWidth,
+		percentReference,
+		precision
+	}
+}
+
+function remToEmDirect(value: number, resolved: ReturnType<typeof resolveOptions>): number {
+	return value * (resolved.rootFontSize / resolved.elementFontSize)
+}
+
+function emToRemDirect(value: number, resolved: ReturnType<typeof resolveOptions>): number {
+	return value * (resolved.elementFontSize / resolved.rootFontSize)
+}
+
+function valueToPx(
+	value: number,
+	fromUnit: CssLengthUnit,
+	resolved: ReturnType<typeof resolveOptions>
+): number {
+	if (ABSOLUTE_UNITS.includes(fromUnit)) {
+		return toPxFromAbsolute(value, fromUnit)
+	}
+	if (fromUnit === 'rem') {
+		return value * (resolved.rootFontSize ?? 0)
+	}
+	if (fromUnit === 'em') {
+		return value * (resolved.elementFontSize ?? 0)
+	}
+	if (fromUnit === 'vw') {
+		if (resolved.viewportWidth === 0) {
+			throw new Error('viewportWidth is required for vw conversion')
+		}
+		return (value / 100) * resolved.viewportWidth
+	}
+	if (fromUnit === 'vh') {
+		if (resolved.viewportHeight === 0) {
+			throw new Error('viewportHeight is required for vh conversion')
+		}
+		return (value / 100) * resolved.viewportHeight
+	}
+	if (fromUnit === 'vmin') {
+		if (resolved.viewportWidth === 0 || resolved.viewportHeight === 0) {
+			throw new Error('viewportWidth and viewportHeight are required for vmin conversion')
+		}
+		return (value / 100) * Math.min(resolved.viewportWidth, resolved.viewportHeight)
+	}
+	if (fromUnit === 'vmax') {
+		if (resolved.viewportWidth === 0 || resolved.viewportHeight === 0) {
+			throw new Error('viewportWidth and viewportHeight are required for vmax conversion')
+		}
+		return (value / 100) * Math.max(resolved.viewportWidth, resolved.viewportHeight)
+	}
+	if (LINE_UNITS.includes(fromUnit)) {
+		if (resolved.lineHeight === 0) {
+			throw new Error('lineHeight is required for lh/rlh conversion')
+		}
+		return value * resolved.lineHeight
+	}
+	if (fromUnit === 'ch') {
+		return value * resolved.chWidth
+	}
+	if (fromUnit === '%') {
+		if (resolved.percentReference === 0) {
+			throw new Error('percentReference is required for % conversion')
+		}
+		return (value / 100) * resolved.percentReference
+	}
+	throw new Error(`Unsupported unit: ${fromUnit}`)
+}
+
+function pxToValue(
+	px: number,
+	toUnit: CssLengthUnit,
+	resolved: ReturnType<typeof resolveOptions>
+): number {
+	if (ABSOLUTE_UNITS.includes(toUnit)) {
+		return fromPxToAbsolute(px, toUnit)
+	}
+	if (toUnit === 'rem') {
+		return px / resolved.rootFontSize
+	}
+	if (toUnit === 'em') {
+		return px / resolved.elementFontSize
+	}
+	if (toUnit === 'vw') {
+		if (resolved.viewportWidth === 0) {
+			throw new Error('viewportWidth is required for vw conversion')
+		}
+		return (px / resolved.viewportWidth) * 100
+	}
+	if (toUnit === 'vh') {
+		if (resolved.viewportHeight === 0) {
+			throw new Error('viewportHeight is required for vh conversion')
+		}
+		return (px / resolved.viewportHeight) * 100
+	}
+	if (toUnit === 'vmin') {
+		if (resolved.viewportWidth === 0 || resolved.viewportHeight === 0) {
+			throw new Error('viewportWidth and viewportHeight are required for vmin conversion')
+		}
+		return (px / Math.min(resolved.viewportWidth, resolved.viewportHeight)) * 100
+	}
+	if (toUnit === 'vmax') {
+		if (resolved.viewportWidth === 0 || resolved.viewportHeight === 0) {
+			throw new Error('viewportWidth and viewportHeight are required for vmax conversion')
+		}
+		return (px / Math.max(resolved.viewportWidth, resolved.viewportHeight)) * 100
+	}
+	if (LINE_UNITS.includes(toUnit)) {
+		if (resolved.lineHeight === 0) {
+			throw new Error('lineHeight is required for lh/rlh conversion')
+		}
+		return px / resolved.lineHeight
+	}
+	if (toUnit === 'ch') {
+		return px / resolved.chWidth
+	}
+	if (toUnit === '%') {
+		if (resolved.percentReference === 0) {
+			throw new Error('percentReference is required and must be non-zero for conversion to %')
+		}
+		return (px / resolved.percentReference) * 100
+	}
+	throw new Error(`Unsupported unit: ${toUnit}`)
+}
+
+function toPxFromAbsolute(value: number, unit: CssLengthUnit): number {
+	switch (unit) {
+		case 'px':
+			return value
+		case 'pt':
+			return (value * PX_PER_IN) / PT_PER_IN
+		case 'pc':
+			return (value * PX_PER_IN) / PC_PER_IN
+		case 'in':
+			return value * PX_PER_IN
+		case 'cm':
+			return (value * PX_PER_IN) / CM_PER_IN
+		case 'mm':
+			return (value * PX_PER_IN) / MM_PER_IN
+		default:
+			return value
+	}
+}
+
+function fromPxToAbsolute(px: number, unit: CssLengthUnit): number {
+	switch (unit) {
+		case 'px':
+			return px
+		case 'pt':
+			return (px * PT_PER_IN) / PX_PER_IN
+		case 'pc':
+			return (px * PC_PER_IN) / PX_PER_IN
+		case 'in':
+			return px / PX_PER_IN
+		case 'cm':
+			return (px * CM_PER_IN) / PX_PER_IN
+		case 'mm':
+			return (px * MM_PER_IN) / PX_PER_IN
+		default:
+			return px
+	}
+}

package/src/units/create-css-unit-converter.ts

@@ -0,0 +1,30 @@
+import { convertCssUnit } from './convert-css-unit.ts'
+import type { CssLengthUnit, CssUnitConverterContext } from './css-unit-converter.types.ts'
+
+/**
+ * Creates a pre-configured CSS unit converter with fixed context.
+ *
+ * @param context - Root font size, viewport, line height, etc. Omitted values use browser auto-detect when available.
+ * @returns A converter function that accepts value and toUnit (and optional fromUnit override).
+ *
+ * @example
+ * ```ts
+ * const convert = createCssUnitConverter({
+ *   rootFontSize: 16,
+ *   viewportWidth: 375,
+ *   viewportHeight: 812,
+ * })
+ * convert('1rem', 'px')   // 16
+ * convert('10vw', 'px')   // 37.5
+ * convert(16, 'rem', { fromUnit: 'px' })  // 1
+ * ```
+ */
+export function createCssUnitConverter(context?: CssUnitConverterContext) {
+	return function convert(
+		value: number | string,
+		toUnit: CssLengthUnit,
+		options?: { fromUnit?: CssLengthUnit | undefined } | undefined
+	): number | null | undefined {
+		return convertCssUnit(value, toUnit, { ...context, ...options })
+	}
+}

package/src/units/css-unit-converter.types.ts

@@ -0,0 +1,49 @@
+/**
+ * Supported CSS length units for conversion.
+ */
+export type CssLengthUnit =
+	| 'px'
+	| 'pt'
+	| 'pc'
+	| 'in'
+	| 'cm'
+	| 'mm'
+	| 'rem'
+	| 'em'
+	| 'vw'
+	| 'vh'
+	| 'vmin'
+	| 'vmax'
+	| 'lh'
+	| 'rlh'
+	| 'ch'
+	| '%'
+
+/**
+ * Options for convertCssUnit.
+ */
+export interface ConvertCssUnitOptions {
+	/** Override when value is number or unitless string. Default: 'px'. */
+	fromUnit?: CssLengthUnit | undefined
+	/** Root font size in px for rem. Auto: getRemToPxScale() in browser. Default: 16. */
+	rootFontSize?: number | undefined
+	/** Element font size in px for em. Default: 16. */
+	elementFontSize?: number | undefined
+	/** Viewport width in px for vw, vmin, vmax. Auto: window.innerWidth in browser. */
+	viewportWidth?: number | undefined
+	/** Viewport height in px for vh, vmin, vmax. Auto: window.innerHeight in browser. */
+	viewportHeight?: number | undefined
+	/** Line height in px for lh, rlh. */
+	lineHeight?: number | undefined
+	/** Width of "0" character in px for ch. Default: ~0.5em. */
+	chWidth?: number | undefined
+	/** Value that 100% equals (for % conversions). */
+	percentReference?: number | undefined
+	/** Decimal places for output. Default: 4. */
+	precision?: number | undefined
+}
+
+/**
+ * Context for createCssUnitConverter (pre-configured values).
+ */
+export type CssUnitConverterContext = Omit<ConvertCssUnitOptions, 'fromUnit'>

package/src/units/get-css-unit.ts

@@ -0,0 +1,24 @@
+import { parseCssValue } from './parse-css-value.ts'
+
+/**
+ * Extracts the unit from a CSS value string.
+ * Thin wrapper around parseCssValue.
+ *
+ * @param value - The CSS value to parse (e.g. '16px', '1.5rem', '100%'). Pass-through for null/undefined.
+ * @returns The unit string, undefined for numbers or unitless strings, or null/undefined when input is null/undefined
+ *
+ * @example
+ * ```ts
+ * getCssUnit('16px')   // 'px'
+ * getCssUnit('1rem')   // 'rem'
+ * getCssUnit('100%')   // '%'
+ * getCssUnit('0')      // undefined
+ * getCssUnit('16')     // undefined
+ * getCssUnit(null)     // null
+ * getCssUnit(undefined) // undefined
+ * ```
+ */
+export function getCssUnit(value: number | string | null | undefined): string | null | undefined {
+	if (value === null || value === undefined) return value
+	return parseCssValue(value)[1]
+}

package/src/units/is-effectively-zero.ts

@@ -0,0 +1,35 @@
+import { parseCssNumber } from './parse-css-number.ts'
+
+/**
+ * Determines if a CSS value is effectively 0 regardless of unit.
+ *
+ * @param value - The CSS value to check. Can be a number or string (e.g. '0px', '0rem', '0%'). Pass-through for null/undefined.
+ * @param options - Optional configuration
+ * @param options.epsilon - Floating-point tolerance. Default 1e-10. Use 0 for strict equality.
+ * @returns true if the value is effectively zero, false otherwise, or null/undefined when input is null/undefined
+ *
+ * @example
+ * ```ts
+ * isEffectivelyZero(0)           // true
+ * isEffectivelyZero('0px')       // true
+ * isEffectivelyZero('0rem')      // true
+ * isEffectivelyZero('0%')        // true
+ * isEffectivelyZero('1px')       // false
+ * isEffectivelyZero(0.00000000001)  // true (within default epsilon)
+ * isEffectivelyZero(0.0001, { epsilon: 0.001 })  // true
+ * isEffectivelyZero(null)        // null
+ * isEffectivelyZero(undefined)   // undefined
+ * ```
+ */
+export function isEffectivelyZero(
+	value: number | string | null | undefined,
+	options?: { epsilon?: number | undefined } | undefined
+): boolean | null | undefined {
+	const parsed = parseCssNumber(value)
+	if (parsed === null || parsed === undefined) return parsed
+	if (!Number.isFinite(parsed)) {
+		return false
+	}
+	const epsilon = options?.epsilon ?? 1e-10
+	return Math.abs(parsed) <= epsilon
+}

package/src/units/parse-css-number.ts

@@ -0,0 +1,26 @@
+import { parseCssValue } from './parse-css-value.ts'
+
+/**
+ * Extracts the numeric part from any CSS length/percentage value.
+ * Thin wrapper around parseCssValue.
+ *
+ * @param value - The CSS value to parse. Can be a number or string (e.g. '16px', '1.5rem', '100%')
+ * @returns The numeric value, or NaN for invalid input. Passes through null and undefined.
+ *
+ * @example
+ * ```ts
+ * parseCssNumber('16px')   // 16
+ * parseCssNumber('1.5rem') // 1.5
+ * parseCssNumber('100%')   // 100
+ * parseCssNumber('0lh')    // 0
+ * parseCssNumber(16)       // 16
+ * parseCssNumber('abc')    // NaN
+ * parseCssNumber(null)     // null
+ * parseCssNumber(undefined) // undefined
+ * ```
+ */
+export function parseCssNumber(
+	value: number | string | null | undefined
+): number | null | undefined {
+	return parseCssValue(value)[0]
+}

package/src/units/parse-css-value.ts

@@ -0,0 +1,35 @@
+/**
+ * Parses a CSS value in one pass and returns both the numeric part and the unit.
+ * Powers parseCssNumber, getCssUnit, and isEffectivelyZero.
+ *
+ * @param value - The CSS value to parse. Can be a number or string (e.g. '16px', '1.5rem', '100%')
+ * @returns A tuple of [number, unit | undefined]. Unit is undefined for numbers or unitless strings.
+ *
+ * @example
+ * ```ts
+ * parseCssValue('16px')    // [16, 'px']
+ * parseCssValue('1.5rem')  // [1.5, 'rem']
+ * parseCssValue('100%')    // [100, '%']
+ * parseCssValue('0')       // [0, undefined]
+ * parseCssValue(16)        // [16, undefined]
+ * parseCssValue('abc')     // [NaN, undefined]
+ * ```
+ */
+export function parseCssValue(
+	value: number | string | null | undefined
+): [number | null | undefined, string | undefined] {
+	if (value === undefined || value === null) {
+		return [value, undefined]
+	}
+	if (typeof value === 'number') {
+		return [value, undefined]
+	}
+	const s = String(value).trim()
+	const match = s.match(/^(-?\d*\.?\d+)\s*(.*)$/)
+	if (!match) {
+		return [Number.NaN, undefined]
+	}
+	const num = Number.parseFloat(match[1] ?? '')
+	const unit = (match[2] ?? '').trim()
+	return [num, unit === '' ? undefined : unit]
+}

package/src/units/px-2-num.ts

@@ -1,8 +1,9 @@
 /**
  * Converts pixel values to numbers.
+ * Alias for {@link parseCssNumber}. Passes through null and undefined.
  *
  * @param px - The pixel value to convert. Can be a number or string (e.g. '16px' or '16')
- * @returns The numeric value
+ * @returns The numeric value, or null/undefined when input is null/undefined
  *
  * @example
  * ```ts
@@ -10,8 +11,8 @@
  * px2num('32px') // 32
  * px2num('12.5px') // 12.5
  * px2num('0px') // 0
+ * px2num(null) // null
+ * px2num(undefined) // undefined
  * ```
  */
-export function px2num(px: number | string | undefined): number {
-	return typeof px === 'string' ? Number.parseFloat(px.replace(/px$/, '')) : Number(px)
-}
+export { parseCssNumber as px2num } from './parse-css-number.ts'

package/src/units/px-2-rem.ts

@@ -5,20 +5,24 @@
  * @param options - Optional configuration
  * @param options.base - Base pixel value to calculate rem units from. Defaults to 16
  * @param options.precision - Number of decimal places in the output. Defaults to 4
- * @returns The converted value as a string with 'rem' units
+ * @returns The converted value, or null/undefined if input is null/undefined
  *
  * @example
  * ```ts
- * px2rem(16) // '1.0000'
- * px2rem('32px') // '2.0000'
- * px2rem(20, { base: 20 }) // '1.0000'
- * px2rem(13, { precision: 2 }) // '0.81'
+ * px2rem(16) // 1
+ * px2rem('32px') // 2
+ * px2rem(20, { base: 20 }) // 1
+ * px2rem(13, { precision: 2 }) // 0.81
+ * px2rem(null) // null
+ * px2rem(undefined) // undefined
  * ```
  */
 export function px2rem(
-	px: number | string,
-	options?: { base?: number | undefined; precision?: number | undefined }
-): number {
+	px: number | string | null | undefined,
+	options?: { base?: number | undefined; precision?: number | undefined } | undefined
+): number | null | undefined {
+	if (px === null || px === undefined) return px
+
 	const { base = 16, precision = 4 } = options ?? {}
 
 	if (typeof px === 'string') {

package/src/units/rem-2-px.ts

@@ -5,26 +5,28 @@
  * @param options - Optional configuration
  * @param options.base - Base pixel value to calculate pixels from. Defaults to 16
  * @param options.precision - Number of decimal places in the output. Defaults to 4
- * @returns The converted value as a string with 'px' units
+ * @returns The converted value, or null/undefined if input is null/undefined
  *
  * @example
  * ```ts
- * rem2px(1) // '16.0000'
- * rem2px('2rem') // '32.0000'
- * rem2px(1, { base: 20 }) // '20.0000'
- * rem2px(0.8125, { precision: 2 }) // '13.00'
+ * rem2px(1) // 16
+ * rem2px('2rem') // 32
+ * rem2px(1, { base: 20 }) // 20
+ * rem2px(0.8125, { precision: 2 }) // 13
+ * rem2px(null) // null
+ * rem2px(undefined) // undefined
  * ```
  */
 export function rem2px(
-	rem: number | string,
+	rem: number | string | null | undefined,
 	options?: { base?: number | undefined; precision?: number | undefined }
-): number {
-	const { base = 16, precision = 4 } = options ?? {}
+): number | null | undefined {
+	if (rem === null || rem === undefined) return rem
 
+	const { base = 16, precision = 4 } = options ?? {}
 	if (typeof rem === 'string') {
 		rem = rem.replace(/rem$/, '')
 		rem = Number.parseFloat(rem)
 	}
-
 	return Number((rem * base).toFixed(precision))
 }

package/dist/units/px-2-num.cjs

@@ -1,23 +0,0 @@
-
-//#region src/units/px-2-num.ts
-/**
-* Converts pixel values to numbers.
-*
-* @param px - The pixel value to convert. Can be a number or string (e.g. '16px' or '16')
-* @returns The numeric value
-*
-* @example
-* ```ts
-* px2num(16) // 16
-* px2num('32px') // 32
-* px2num('12.5px') // 12.5
-* px2num('0px') // 0
-* ```
-*/
-function px2num(px) {
-	return typeof px === "string" ? Number.parseFloat(px.replace(/px$/, "")) : Number(px);
-}
-
-//#endregion
-exports.px2num = px2num;
-//# sourceMappingURL=px-2-num.cjs.map

package/dist/units/px-2-num.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"px-2-num.cjs","names":[],"sources":["../../src/units/px-2-num.ts"],"sourcesContent":["/**\n * Converts pixel values to numbers.\n *\n * @param px - The pixel value to convert. Can be a number or string (e.g. '16px' or '16')\n * @returns The numeric value\n *\n * @example\n * ```ts\n * px2num(16) // 16\n * px2num('32px') // 32\n * px2num('12.5px') // 12.5\n * px2num('0px') // 0\n * ```\n */\nexport function px2num(px: number | string | undefined): number {\n\treturn typeof px === 'string' ? Number.parseFloat(px.replace(/px$/, '')) : Number(px)\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAcA,SAAgB,OAAO,IAAyC;AAC/D,QAAO,OAAO,OAAO,WAAW,OAAO,WAAW,GAAG,QAAQ,OAAO,GAAG,CAAC,GAAG,OAAO,GAAG"}

package/dist/units/px-2-num.d.cts

@@ -1,19 +0,0 @@
-//#region src/units/px-2-num.d.ts
-/**
- * Converts pixel values to numbers.
- *
- * @param px - The pixel value to convert. Can be a number or string (e.g. '16px' or '16')
- * @returns The numeric value
- *
- * @example
- * ```ts
- * px2num(16) // 16
- * px2num('32px') // 32
- * px2num('12.5px') // 12.5
- * px2num('0px') // 0
- * ```
- */
-declare function px2num(px: number | string | undefined): number;
-//#endregion
-export { px2num };
-//# sourceMappingURL=px-2-num.d.cts.map

package/dist/units/px-2-num.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"px-2-num.d.cts","names":[],"sources":["../../src/units/px-2-num.ts"],"sourcesContent":[],"mappings":";;AAcA;;;;;;;;;;;;;iBAAgB,MAAA"}

package/dist/units/px-2-num.d.mts

@@ -1,19 +0,0 @@
-//#region src/units/px-2-num.d.ts
-/**
- * Converts pixel values to numbers.
- *
- * @param px - The pixel value to convert. Can be a number or string (e.g. '16px' or '16')
- * @returns The numeric value
- *
- * @example
- * ```ts
- * px2num(16) // 16
- * px2num('32px') // 32
- * px2num('12.5px') // 12.5
- * px2num('0px') // 0
- * ```
- */
-declare function px2num(px: number | string | undefined): number;
-//#endregion
-export { px2num };
-//# sourceMappingURL=px-2-num.d.mts.map

package/dist/units/px-2-num.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"px-2-num.d.mts","names":[],"sources":["../../src/units/px-2-num.ts"],"sourcesContent":[],"mappings":";;AAcA;;;;;;;;;;;;;iBAAgB,MAAA"}