@doubao-apps/taro-runtime 0.0.26 → 0.0.27

package/dist/api/device/accelerometer.d.ts

@@ -3,7 +3,15 @@ type TaroStartAccelerometerOption = Parameters<typeof Taro.startAccelerometer>[0
 type TaroStartAccelerometerResult = Awaited<ReturnType<typeof Taro.startAccelerometer>>;
 type TaroStopAccelerometerOption = Parameters<typeof Taro.stopAccelerometer>[0];
 type TaroStopAccelerometerResult = Awaited<ReturnType<typeof Taro.stopAccelerometer>>;
+type TaroAccelerometerChangeCallback = Parameters<typeof Taro.onAccelerometerChange>[0];
+type TaroAccelerometerChangeCallbackResult = Parameters<TaroAccelerometerChangeCallback>[0];
+type AccelerometerChangeCallbackResult = TaroAccelerometerChangeCallbackResult & {
+    timestamp: number;
+};
+type AccelerometerChangeCallback = (result: AccelerometerChangeCallbackResult) => void;
 export declare function startAccelerometer(option?: TaroStartAccelerometerOption): Promise<TaroStartAccelerometerResult>;
 export declare function stopAccelerometer(option?: TaroStopAccelerometerOption): Promise<TaroStopAccelerometerResult>;
+export declare function onAccelerometerChange(callback: AccelerometerChangeCallback): void;
+export declare function offAccelerometerChange(callback?: AccelerometerChangeCallback): void;
 export {};
 //# sourceMappingURL=accelerometer.d.ts.map

package/dist/api/device/accelerometer.js

@@ -1,5 +1,6 @@
 import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
 import { runCallbackApi } from '../utils.js';
+const accelerometerChangeCallbacks = new Map();
 export async function startAccelerometer(option) {
     return runCallbackApi('startAccelerometer', option, () => appFrameworkApi.startAccelerometer({
         interval: option?.interval
@@ -8,4 +9,34 @@ export async function startAccelerometer(option) {
 export async function stopAccelerometer(option) {
     return runCallbackApi('stopAccelerometer', option, () => appFrameworkApi.stopAccelerometer({}));
 }
+export function onAccelerometerChange(callback) {
+    if (typeof callback !== 'function' || accelerometerChangeCallbacks.has(callback)) {
+        return;
+    }
+    const unregister = appFrameworkApi.onAccelerometerChange((event) => {
+        callback({
+            x: event.x,
+            y: event.y,
+            z: event.z,
+            timestamp: event.timestamp
+        });
+    });
+    accelerometerChangeCallbacks.set(callback, unregister);
+}
+export function offAccelerometerChange(callback) {
+    if (typeof callback === 'function') {
+        const unregister = accelerometerChangeCallbacks.get(callback);
+        if (!unregister) {
+            return;
+        }
+        unregister();
+        accelerometerChangeCallbacks.delete(callback);
+        return;
+    }
+    if (callback !== undefined) {
+        return;
+    }
+    accelerometerChangeCallbacks.forEach((unregister) => unregister());
+    accelerometerChangeCallbacks.clear();
+}
 //# sourceMappingURL=accelerometer.js.map

package/dist/api/device/battery.d.ts

@@ -1,6 +1,12 @@
 import type Taro from '@tarojs/taro';
 type TaroGetBatteryInfoOption = Parameters<typeof Taro.getBatteryInfo>[0];
 type TaroGetBatteryInfoResult = Awaited<ReturnType<typeof Taro.getBatteryInfo>>;
+type BatteryInfoChangeCallbackResult = {
+    isLowPowerModeEnabled: boolean;
+};
+type BatteryInfoChangeCallback = (result: BatteryInfoChangeCallbackResult) => void;
 export declare function getBatteryInfo(option?: TaroGetBatteryInfoOption): Promise<TaroGetBatteryInfoResult>;
+export declare function onBatteryInfoChange(callback: BatteryInfoChangeCallback): void;
+export declare function offBatteryInfoChange(callback?: BatteryInfoChangeCallback): void;
 export {};
 //# sourceMappingURL=battery.d.ts.map

package/dist/api/device/battery.js

@@ -1,5 +1,6 @@
 import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
 import { buildOkCallbackResult, runTaroApi } from '../utils.js';
+const batteryInfoChangeCallbacks = new Map();
 function buildGetBatteryInfoResult(result) {
     return {
         isCharging: Boolean(result.isCharging),
@@ -10,4 +11,31 @@ function buildGetBatteryInfoResult(result) {
 export async function getBatteryInfo(option) {
     return runTaroApi('getBatteryInfo', option, async () => buildGetBatteryInfoResult(await appFrameworkApi.getBatteryInfo({})));
 }
+export function onBatteryInfoChange(callback) {
+    if (typeof callback !== 'function' || batteryInfoChangeCallbacks.has(callback)) {
+        return;
+    }
+    const unregister = appFrameworkApi.onBatteryInfoChange((event) => {
+        callback({
+            isLowPowerModeEnabled: Boolean(event.isLowPowerModeEnabled)
+        });
+    });
+    batteryInfoChangeCallbacks.set(callback, unregister);
+}
+export function offBatteryInfoChange(callback) {
+    if (typeof callback === 'function') {
+        const unregister = batteryInfoChangeCallbacks.get(callback);
+        if (!unregister) {
+            return;
+        }
+        unregister();
+        batteryInfoChangeCallbacks.delete(callback);
+        return;
+    }
+    if (callback !== undefined) {
+        return;
+    }
+    batteryInfoChangeCallbacks.forEach((unregister) => unregister());
+    batteryInfoChangeCallbacks.clear();
+}
 //# sourceMappingURL=battery.js.map

package/dist/api/device/gyroscope.d.ts

@@ -3,7 +3,15 @@ type TaroStartGyroscopeOption = Parameters<typeof Taro.startGyroscope>[0];
 type TaroStartGyroscopeResult = Awaited<ReturnType<typeof Taro.startGyroscope>>;
 type TaroStopGyroscopeOption = Parameters<typeof Taro.stopGyroscope>[0];
 type TaroStopGyroscopeResult = Awaited<ReturnType<typeof Taro.stopGyroscope>>;
+type TaroGyroscopeChangeCallback = Parameters<typeof Taro.onGyroscopeChange>[0];
+type TaroGyroscopeChangeCallbackResult = Parameters<TaroGyroscopeChangeCallback>[0];
+type GyroscopeChangeCallbackResult = TaroGyroscopeChangeCallbackResult & {
+    timestamp: number;
+};
+type GyroscopeChangeCallback = (result: GyroscopeChangeCallbackResult) => void;
 export declare function startGyroscope(option: TaroStartGyroscopeOption): Promise<TaroStartGyroscopeResult>;
 export declare function stopGyroscope(option?: TaroStopGyroscopeOption): Promise<TaroStopGyroscopeResult>;
+export declare function onGyroscopeChange(callback: GyroscopeChangeCallback): void;
+export declare function offGyroscopeChange(callback?: GyroscopeChangeCallback): void;
 export {};
 //# sourceMappingURL=gyroscope.d.ts.map

package/dist/api/device/gyroscope.js

@@ -1,5 +1,6 @@
 import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
 import { runCallbackApi } from '../utils.js';
+const gyroscopeChangeCallbacks = new Map();
 export async function startGyroscope(option) {
     return runCallbackApi('startGyroscope', option, () => appFrameworkApi.startGyroscope({
         interval: option.interval
@@ -8,4 +9,34 @@ export async function startGyroscope(option) {
 export async function stopGyroscope(option) {
     return runCallbackApi('stopGyroscope', option, () => appFrameworkApi.stopGyroscope({}));
 }
+export function onGyroscopeChange(callback) {
+    if (typeof callback !== 'function' || gyroscopeChangeCallbacks.has(callback)) {
+        return;
+    }
+    const unregister = appFrameworkApi.onGyroscopeChange((event) => {
+        callback({
+            x: event.x,
+            y: event.y,
+            z: event.z,
+            timestamp: event.timestamp
+        });
+    });
+    gyroscopeChangeCallbacks.set(callback, unregister);
+}
+export function offGyroscopeChange(callback) {
+    if (typeof callback === 'function') {
+        const unregister = gyroscopeChangeCallbacks.get(callback);
+        if (!unregister) {
+            return;
+        }
+        unregister();
+        gyroscopeChangeCallbacks.delete(callback);
+        return;
+    }
+    if (callback !== undefined) {
+        return;
+    }
+    gyroscopeChangeCallbacks.forEach((unregister) => unregister());
+    gyroscopeChangeCallbacks.clear();
+}
 //# sourceMappingURL=gyroscope.js.map

package/dist/components/PickerView/index.jsx

@@ -1,42 +1,50 @@
-import { Children, cloneElement } from 'react';
 import { PickerView as DoubaoPickerView, PickerColumn as DoubaoPickerColumn } from '@byted-doubao-apps/components';
-import { buildOptionsFromRange, mapPickerViewProps, toPickerViewChangeEvent, warnUnsupportedPickerView } from './map.js';
+import { warnUnsupported } from '../base/warn-unsupported.js';
+import { buildOptionsFromChildren, buildOptionsFromRange, mapPickerViewColumnProps, mapPickerViewProps, resolveExplicitItemHeight, resolveItemHeightFromChildren, resolveSelectedIndexValue, toPickerViewChangeEvent } from './map.js';
+const PICKER_VIEW_COLUMN_TYPE = 'taro-picker-view-column';
 export function PickerView(props) {
-    const { value, onChange, children, ...rest } = props;
-    const { mapped, unsupported } = mapPickerViewProps(rest);
-    warnUnsupportedPickerView(unsupported);
-    // Collect ranges from child columns to compute indices on change
-    const ranges = [];
-    const childrenWithProps = Children.map(children, (child, index) => {
-        if (!child)
-            return child;
-        // We expect child to be <PickerViewColumn range={...} />
-        const range = child?.props?.range;
-        const options = buildOptionsFromRange(range);
-        ranges[index] = options;
-        const selectedIndex = Array.isArray(value) ? value[index] : undefined;
-        const selectedValue = selectedIndex != null && options[selectedIndex] ? options[selectedIndex].value : undefined;
-        return cloneElement(child, {
-            __mappedOptions: options,
-            __mappedValue: selectedValue
+    const { value, defaultValue, onChange, children, itemHeight: propItemHeight, ...rest } = props;
+    const { mapped, unsupported, indicatorItemHeight } = mapPickerViewProps(rest);
+    const explicitItemHeight = resolveExplicitItemHeight(propItemHeight);
+    const pickerViewId = typeof mapped.id === 'string' ? mapped.id : '';
+    warnUnsupported('PickerView', propItemHeight !== undefined && explicitItemHeight === undefined
+        ? [...unsupported, 'itemHeight must be a positive number']
+        : unsupported);
+    const columns = [];
+    toChildArray(children).forEach((child) => {
+        if (!isPickerViewColumnElement(child)) {
+            return;
+        }
+        const columnProps = child.props;
+        const { className, style, unsupported: columnUnsupported } = mapPickerViewColumnProps(columnProps);
+        warnUnsupported('PickerViewColumn', columnUnsupported);
+        columns.push({
+            options: Array.isArray(columnProps.range)
+                ? buildOptionsFromRange(columnProps.range)
+                : buildOptionsFromChildren(columnProps.children),
+            className,
+            style,
+            itemHeight: resolveItemHeightFromChildren(columnProps.children)
         });
     });
+    const resolvedItemHeight = explicitItemHeight ??
+        indicatorItemHeight ??
+        columns.find((column) => column.itemHeight !== undefined)?.itemHeight;
     const handleChange = (values, selectedOptions) => {
-        // Map selected values back to indices per column
-        const indices = values.map((val, idx) => {
-            const opts = ranges[idx] ?? [];
-            const found = opts.findIndex((opt) => opt.value === val);
-            return found >= 0 ? found : 0;
+        const indices = values.map((selectedValue, index) => {
+            if (typeof selectedValue === 'number') {
+                return selectedValue;
+            }
+            const optionValue = selectedOptions[index]?.value;
+            return typeof optionValue === 'number' ? optionValue : 0;
         });
-        onChange?.(toPickerViewChangeEvent(indices));
+        onChange?.(toPickerViewChangeEvent(indices, pickerViewId));
     };
-    return (<DoubaoPickerView {...mapped} onChange={onChange ? handleChange : undefined}>
-      {Children.map(childrenWithProps, (child) => {
-            const options = child?.props?.__mappedOptions;
-            const valueForColumn = child?.props?.__mappedValue;
-            const columnClassName = child?.props?.className;
-            const columnStyle = child?.props?.style;
-            return (<DoubaoPickerColumn options={options ?? []} value={valueForColumn} className={columnClassName} style={columnStyle}/>);
+    return (<DoubaoPickerView {...mapped} itemHeight={resolvedItemHeight} onChange={onChange ? handleChange : undefined}>
+      {columns.map(({ options, className, style }, index) => {
+            const valueForColumn = resolveSelectedIndexValue(value, index, options);
+            const defaultValueForColumn = resolveSelectedIndexValue(defaultValue, index, options);
+            return (<DoubaoPickerColumn key={index} options={options} value={valueForColumn} defaultValue={defaultValueForColumn} className={className} style={style}/>);
         })}
     </DoubaoPickerView>);
 }
@@ -44,4 +52,29 @@ export function PickerViewColumn(_props) {
     // This is a placeholder wrapper. Real rendering is performed by PickerView above after mapping.
     return null;
 }
+PickerViewColumn.__TARO_PICKER_VIEW_CHILD_TYPE = PICKER_VIEW_COLUMN_TYPE;
+function isPickerViewColumnElement(child) {
+    if (!isReactElement(child)) {
+        return false;
+    }
+    const childType = child.type;
+    return (childType.__TARO_PICKER_VIEW_CHILD_TYPE === PICKER_VIEW_COLUMN_TYPE ||
+        childType.displayName === 'PickerViewColumn' ||
+        childType.name === 'PickerViewColumn' ||
+        child.type === 'picker-view-column' ||
+        child.type === 'taro-picker-view-column-core');
+}
+function isReactElement(node) {
+    return (typeof node === 'object' &&
+        node !== null &&
+        node.$$typeof === Symbol.for('react.element') &&
+        'type' in node &&
+        'props' in node);
+}
+function toChildArray(children) {
+    if (children === null || children === undefined || typeof children === 'boolean') {
+        return [];
+    }
+    return Array.isArray(children) ? children.flatMap(toChildArray) : [children];
+}
 //# sourceMappingURL=index.jsx.map

package/dist/components/PickerView/map.d.ts

@@ -1,36 +1,51 @@
 import type { CSSProperties } from '@lynx-js/types';
+import type { ReactNode } from 'react';
+import type { PickerViewProps as TaroPickerViewPropsBase } from '@tarojs/components';
 import type { PickerViewProps as LynxPickerViewProps, PickerColumnOption } from '@byted-doubao-apps/framework/components';
-export type TaroPickerViewProps = {
-    className?: string;
-    style?: CSSProperties;
-    value?: number[];
-    indicatorStyle?: CSSProperties;
-    maskStyle?: CSSProperties;
-    onChange?: (event: {
-        type: string;
-        timeStamp: number;
-        detail: {
-            value: number[];
-        };
-    }) => void;
-    children?: any;
+export type TaroPickerViewProps = TaroPickerViewPropsBase & {
+    children?: ReactNode;
 };
 export type TaroPickerViewColumnProps = {
+    children?: ReactNode;
     range?: Array<string | number>;
     className?: string;
     style?: CSSProperties;
 };
-export declare function toPickerViewChangeEvent(indices: number[]): {
+export type PickerViewChangeEvent = {
     type: string;
     timeStamp: number;
+    target: {
+        id: string;
+        tagName: string;
+        dataset: Record<string, unknown>;
+    };
+    currentTarget: {
+        id: string;
+        tagName: string;
+        dataset: Record<string, unknown>;
+    };
     detail: {
         value: number[];
     };
+    preventDefault: () => void;
+    stopPropagation: () => void;
 };
+export declare function toPickerViewChangeEvent(indices: number[], pickerViewId?: string): PickerViewChangeEvent;
 export declare function buildOptionsFromRange(range?: Array<string | number>): PickerColumnOption[];
-export declare function warnUnsupportedPickerView(unsupported: string[]): void;
+export declare function buildOptionsFromChildren(children?: ReactNode): PickerColumnOption[];
+export declare function resolveSelectedIndexValue(indices: number[] | undefined, columnIndex: number, options: PickerColumnOption[]): number | undefined;
 export declare function mapPickerViewProps(props: TaroPickerViewProps): {
-    mapped: Pick<LynxPickerViewProps, 'className' | 'style'>;
+    mapped: Pick<LynxPickerViewProps, 'className' | 'style'> & Record<string, unknown>;
+    unsupported: string[];
+    pickerViewId: string;
+    indicatorItemHeight: number | undefined;
+};
+export declare function mapPickerViewColumnProps(props: TaroPickerViewColumnProps): {
+    className?: string;
+    style?: CSSProperties;
     unsupported: string[];
 };
+export declare function resolveItemHeightFromChildren(children?: ReactNode): number | undefined;
+export declare function resolveExplicitItemHeight(itemHeight: unknown): number | undefined;
+export declare function resolveItemHeightFromIndicatorStyle(indicatorStyle: unknown): number | undefined;
 //# sourceMappingURL=map.d.ts.map

package/dist/components/PickerView/map.js

@@ -1,29 +1,201 @@
-export function toPickerViewChangeEvent(indices) {
+import { BASE_PROP_MAP } from '../base/prop-map.js';
+export function toPickerViewChangeEvent(indices, pickerViewId = '') {
     return {
         type: 'change',
         timeStamp: Date.now(),
-        detail: { value: indices }
+        target: {
+            id: pickerViewId,
+            tagName: 'picker-view',
+            dataset: {}
+        },
+        currentTarget: {
+            id: pickerViewId,
+            tagName: 'picker-view',
+            dataset: {}
+        },
+        detail: { value: indices },
+        preventDefault: () => { },
+        stopPropagation: () => { }
     };
 }
 export function buildOptionsFromRange(range) {
-    return (range ?? []).map((item) => ({ label: String(item), value: item }));
+    return (range ?? []).map((item, index) => ({ label: String(item), value: index }));
 }
-export function warnUnsupportedPickerView(unsupported) {
-    if (unsupported.length > 0) {
-        // Centralized warn helper exists for other components; keep inline minimal here
-        console.warn(`[PickerView] Unsupported props: ${unsupported.join(', ')}`);
+export function buildOptionsFromChildren(children) {
+    return toChildArray(children).map((child, index) => ({
+        label: extractText(child) || String(index),
+        value: index
+    }));
+}
+export function resolveSelectedIndexValue(indices, columnIndex, options) {
+    const selectedIndex = indices?.[columnIndex];
+    if (selectedIndex === undefined || options.length === 0) {
+        return undefined;
+    }
+    if (typeof selectedIndex !== 'number' || Number.isNaN(selectedIndex)) {
+        return undefined;
     }
+    return Math.min(Math.max(Math.trunc(selectedIndex), 0), options.length - 1);
 }
 export function mapPickerViewProps(props) {
+    const { value: _value, defaultValue: _defaultValue, children: _children, onChange: _onChange, indicatorStyle, indicatorClass, maskStyle, maskClass, immediateChange, onPickStart, onPickEnd, title, ariaLabel, ...rest } = props;
     const unsupported = [];
-    if (props.maskStyle)
+    const indicatorItemHeight = resolveItemHeightFromIndicatorStyle(indicatorStyle);
+    unsupported.push(...getUnsupportedIndicatorStyleWarnings(indicatorStyle, indicatorItemHeight));
+    if (indicatorClass !== undefined)
+        unsupported.push('indicatorClass');
+    if (maskStyle !== undefined)
         unsupported.push('maskStyle');
-    if (props.indicatorStyle)
-        unsupported.push('indicatorStyle');
-    const mapped = {
-        className: props.className,
-        style: props.style
+    if (maskClass !== undefined)
+        unsupported.push('maskClass');
+    if (immediateChange !== undefined)
+        unsupported.push('immediateChange');
+    if (onPickStart !== undefined)
+        unsupported.push('onPickStart');
+    if (onPickEnd !== undefined)
+        unsupported.push('onPickEnd');
+    if (title !== undefined)
+        unsupported.push('title');
+    if (ariaLabel !== undefined)
+        unsupported.push('ariaLabel');
+    const mapped = {};
+    Object.entries(rest).forEach(([key, value]) => {
+        const target = BASE_PROP_MAP[key];
+        if (target) {
+            mapped[target] = value;
+            return;
+        }
+        unsupported.push(key);
+    });
+    return {
+        mapped,
+        unsupported: dedupe(unsupported),
+        pickerViewId: resolveId(mapped.id),
+        indicatorItemHeight
+    };
+}
+export function mapPickerViewColumnProps(props) {
+    const { children: _children, range: _range, className, style, ...rest } = props;
+    return {
+        className,
+        style,
+        unsupported: Object.keys(rest)
     };
-    return { mapped, unsupported };
+}
+export function resolveItemHeightFromChildren(children) {
+    const firstHeight = toChildArray(children)
+        .map((child) => {
+        if (!isReactElement(child)) {
+            return undefined;
+        }
+        return parseStyleHeight(child.props.style);
+    })
+        .find((height) => height !== undefined);
+    return firstHeight;
+}
+export function resolveExplicitItemHeight(itemHeight) {
+    return typeof itemHeight === 'number' && Number.isFinite(itemHeight) && itemHeight > 0
+        ? itemHeight
+        : undefined;
+}
+export function resolveItemHeightFromIndicatorStyle(indicatorStyle) {
+    if (typeof indicatorStyle === 'string') {
+        return parseStyleHeightString(indicatorStyle);
+    }
+    return parseStyleHeight(indicatorStyle);
+}
+function hasRpxIndicatorHeight(indicatorStyle) {
+    if (typeof indicatorStyle === 'string') {
+        return /(?:^|;)\s*height\s*:\s*\d+(?:\.\d+)?rpx\s*(?:;|$)/.test(indicatorStyle);
+    }
+    if (!indicatorStyle || typeof indicatorStyle !== 'object' || Array.isArray(indicatorStyle)) {
+        return false;
+    }
+    const height = indicatorStyle.height;
+    return typeof height === 'string' && /^\d+(?:\.\d+)?rpx$/.test(height.trim());
+}
+function getUnsupportedIndicatorStyleWarnings(indicatorStyle, indicatorItemHeight) {
+    if (indicatorStyle === undefined) {
+        return [];
+    }
+    const unsupported = [];
+    if (hasUnsupportedIndicatorStyleFields(indicatorStyle)) {
+        unsupported.push('indicatorStyle only supports height');
+    }
+    if (hasRpxIndicatorHeight(indicatorStyle)) {
+        unsupported.push('indicatorStyle.height uses rpx, please use px or number');
+    }
+    else if (indicatorItemHeight === undefined) {
+        unsupported.push('indicatorStyle.height must be px or number');
+    }
+    return unsupported;
+}
+function hasUnsupportedIndicatorStyleFields(indicatorStyle) {
+    if (typeof indicatorStyle === 'string') {
+        return parseStyleDeclarationNames(indicatorStyle).some((name) => name !== 'height');
+    }
+    if (!indicatorStyle || typeof indicatorStyle !== 'object' || Array.isArray(indicatorStyle)) {
+        return false;
+    }
+    return Object.keys(indicatorStyle).some((name) => name !== 'height');
+}
+function parseStyleDeclarationNames(style) {
+    return style
+        .split(';')
+        .map((declaration) => declaration.trim())
+        .filter(Boolean)
+        .map((declaration) => declaration.split(':')[0]?.trim())
+        .filter((name) => Boolean(name));
+}
+function extractText(node) {
+    if (node === null || node === undefined || typeof node === 'boolean') {
+        return '';
+    }
+    if (typeof node === 'string' || typeof node === 'number') {
+        return String(node);
+    }
+    if (Array.isArray(node)) {
+        return node.map(extractText).join('');
+    }
+    if (isReactElement(node)) {
+        return extractText(node.props.children);
+    }
+    return '';
+}
+function isReactElement(node) {
+    return (typeof node === 'object' &&
+        node !== null &&
+        node.$$typeof === Symbol.for('react.element') &&
+        'props' in node);
+}
+function toChildArray(children) {
+    if (children === null || children === undefined || typeof children === 'boolean') {
+        return [];
+    }
+    return Array.isArray(children) ? children.flatMap(toChildArray) : [children];
+}
+function resolveId(id) {
+    return typeof id === 'string' ? id : '';
+}
+function dedupe(items) {
+    return Array.from(new Set(items));
+}
+function parseStyleHeight(style) {
+    if (!style || typeof style !== 'object' || Array.isArray(style)) {
+        return undefined;
+    }
+    const height = style.height;
+    if (typeof height === 'number' && Number.isFinite(height)) {
+        return height;
+    }
+    if (typeof height !== 'string') {
+        return undefined;
+    }
+    const match = height.trim().match(/^(\d+(?:\.\d+)?)px$/);
+    return match ? Number(match[1]) : undefined;
+}
+function parseStyleHeightString(style) {
+    const match = style.match(/(?:^|;)\s*height\s*:\s*(\d+(?:\.\d+)?)px\s*(?:;|$)/);
+    return match ? Number(match[1]) : undefined;
 }
 //# sourceMappingURL=map.js.map

package/package.json

@@ -37,7 +37,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "0.0.26",
+  "version": "0.0.27",
   "scripts": {
     "dev": "npm run build -- -w",
     "build": "rimraf dist bundle && tsc -p tsconfig.build.json",