From 13dabc6fbad70a13f34f723c62c27bbfb6db69f4 Mon Sep 17 00:00:00 2001 From: Ruud Date: Thu, 15 Oct 2026 12:33:00 +0200 Subject: [PATCH 1/4] lower yoga wasm to mvp for chrome 57+ --- .changeset/yoga-mvp-wasm.md | 5 + .oxfmtrc.json | 7 +- .oxlintrc.json | 2 +- packages/plugin-flexbox/package.json | 3 +- packages/plugin-flexbox/scripts/vendorYoga.ts | 82 ++++ .../plugin-flexbox/src/YogaManager.spec.ts | 4 +- packages/plugin-flexbox/src/YogaManager.ts | 8 +- .../plugin-flexbox/src/YogaManagerWorker.ts | 5 +- .../util/applyReactPropsToYoga.align.spec.ts | 3 +- .../util/applyReactPropsToYoga.border.spec.ts | 3 +- .../applyReactPropsToYoga.minSize.spec.ts | 3 +- .../applyReactPropsToYoga.position.spec.ts | 3 +- packages/plugin-flexbox/src/yoga/loadYoga.ts | 12 + .../plugin-flexbox/src/yoga/vendor/YGEnums.js | 210 +++++++++ .../src/yoga/vendor/wrapAssembly.d.ts | 5 + .../src/yoga/vendor/wrapAssembly.js | 124 +++++ .../src/yoga/vendor/yoga-wasm-mvp.d.ts | 3 + .../src/yoga/vendor/yoga-wasm-mvp.js | 78 ++++ .../src/yoga/yogaVendor.spec.ts | 436 ++++++++++++++++++ packages/plugin-flexbox/vite.config.ts | 6 + 20 files changed, 988 insertions(+), 14 deletions(-) create mode 100644 .changeset/yoga-mvp-wasm.md create mode 100644 packages/plugin-flexbox/scripts/vendorYoga.ts create mode 100644 packages/plugin-flexbox/src/yoga/loadYoga.ts create mode 100644 packages/plugin-flexbox/src/yoga/vendor/YGEnums.js create mode 100644 packages/plugin-flexbox/src/yoga/vendor/wrapAssembly.d.ts create mode 100644 packages/plugin-flexbox/src/yoga/vendor/wrapAssembly.js create mode 100644 packages/plugin-flexbox/src/yoga/vendor/yoga-wasm-mvp.d.ts create mode 100644 packages/plugin-flexbox/src/yoga/vendor/yoga-wasm-mvp.js create mode 100644 packages/plugin-flexbox/src/yoga/yogaVendor.spec.ts diff --git a/.changeset/yoga-mvp-wasm.md b/.changeset/yoga-mvp-wasm.md new file mode 100644 index 00000000..9f54d133 --- /dev/null +++ b/.changeset/yoga-mvp-wasm.md @@ -0,0 +1,5 @@ +--- +'@plextv/react-lightning-plugin-flexbox': patch +--- + +ship yoga with its wasm lowered to mvp so layout runs on chrome 57-73 tvs, and build the inline worker for chrome 56 like the rest of the package diff --git a/.oxfmtrc.json b/.oxfmtrc.json index 56527329..6bc0a438 100644 --- a/.oxfmtrc.json +++ b/.oxfmtrc.json @@ -7,5 +7,10 @@ "internalPattern": ["@plextv/", "@repo/"], "partitionByNewline": false }, - "ignorePatterns": [".changeset", "**/public", "**/dist"] + "ignorePatterns": [ + ".changeset", + "**/public", + "**/dist", + "packages/plugin-flexbox/src/yoga/vendor" + ] } diff --git a/.oxlintrc.json b/.oxlintrc.json index ec296584..94da6e2b 100644 --- a/.oxlintrc.json +++ b/.oxlintrc.json @@ -20,5 +20,5 @@ "jsx-a11y/mouse-events-have-key-events": "off", "jsx-a11y/click-events-have-key-events": "off" }, - "ignorePatterns": ["dist", ".changeset", "**/public"] + "ignorePatterns": ["dist", ".changeset", "**/public", "packages/plugin-flexbox/src/yoga/vendor"] } diff --git a/packages/plugin-flexbox/package.json b/packages/plugin-flexbox/package.json index 38ee2476..305181b6 100644 --- a/packages/plugin-flexbox/package.json +++ b/packages/plugin-flexbox/package.json @@ -49,7 +49,8 @@ "test:unit": "vitest run --passWithNoTests", "bench": "tsx bench/cli.ts", "bench:update": "tsx bench/cli.ts --update", - "bench:save": "tsx bench/cli.ts save" + "bench:save": "tsx bench/cli.ts save", + "vendor:yoga": "tsx scripts/vendorYoga.ts" }, "dependencies": { "tseep": "catalog:", diff --git a/packages/plugin-flexbox/scripts/vendorYoga.ts b/packages/plugin-flexbox/scripts/vendorYoga.ts new file mode 100644 index 00000000..337eb137 --- /dev/null +++ b/packages/plugin-flexbox/scripts/vendorYoga.ts @@ -0,0 +1,82 @@ +import { execFileSync } from 'node:child_process'; +import { createHash } from 'node:crypto'; +import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; + +// Rebuilds src/yoga/vendor from the installed yoga-layout with its wasm lowered +// to WebAssembly MVP, so Yoga instantiates on Chrome 57-73 (sign-ext needs 74). +// Run `pnpm vendor:yoga` after bumping yoga-layout; yogaVendor.spec.ts fails +// until you do. + +const BINARYEN = 'binaryen@132.0.0'; +const DATA_URI_PREFIX = 'data:application/octet-stream;base64,'; +const SCRIPT_DIR_LINE = 'var _scriptDir = import.meta.url;'; + +const pkgDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'); +const outDir = path.join(pkgDir, 'src/yoga/vendor'); +const yogaDist = path.resolve(fileURLToPath(import.meta.resolve('yoga-layout/load')), '../..'); +const yogaPkgJson = path.join(yogaDist, '../package.json'); +const yogaVersion: string = JSON.parse(readFileSync(yogaPkgJson, 'utf8')).version; + +const readUpstream = (file: string) => + readFileSync(path.join(yogaDist, file), 'utf8').replace(/\n\/\/# sourceMappingURL=.*$/m, '\n'); + +const wasmOpt = (args: string[]) => + execFileSync('pnpm', ['--silent', `--package=${BINARYEN}`, 'dlx', 'wasm-opt', ...args], { + stdio: ['ignore', 'inherit', 'inherit'], + env: { ...process.env, NODE_NO_WARNINGS: '1' }, + }); + +const glue = readUpstream('binaries/yoga-wasm-base64-esm.js'); +const match = glue.match(/data:application\/octet-stream;base64,([A-Za-z0-9+/=]+)/); + +if (!match?.[1]) { + throw new Error('No embedded wasm found in yoga-wasm-base64-esm.js'); +} + +if (!glue.includes(SCRIPT_DIR_LINE)) { + throw new Error(`Expected "${SCRIPT_DIR_LINE}" in the yoga glue, check the upstream build`); +} + +const original = Buffer.from(match[1], 'base64'); +const tmp = mkdtempSync(path.join(tmpdir(), 'yoga-mvp-')); + +try { + const inFile = path.join(tmp, 'yoga.wasm'); + const outFile = path.join(tmp, 'yoga-mvp.wasm'); + + writeFileSync(inFile, original); + wasmOpt([inFile, '--enable-sign-ext', '--signext-lowering', '-o', outFile]); + // Fails (non-zero exit) if anything beyond MVP is left. + wasmOpt([outFile, '--mvp-features', '--quiet', '-o', path.join(tmp, 'validated.wasm')]); + + const lowered = readFileSync(outFile); + const sha = createHash('sha256').update(original).digest('hex'); + const header = [ + `// Generated by scripts/vendorYoga.ts from yoga-layout@${yogaVersion} (MIT, Meta Platforms, Inc.). Do not edit.`, + `// The wasm is lowered to WebAssembly MVP with ${BINARYEN} (--signext-lowering).`, + `// source-wasm-sha256: ${sha}`, + '', + ].join('\n'); + + // import.meta is a syntax error before Chrome 64, and the wasm is a data URI so + // the script dir is never used. + const vendoredGlue = glue + .replace(match[0], DATA_URI_PREFIX + lowered.toString('base64')) + .replace(SCRIPT_DIR_LINE, 'var _scriptDir = "";'); + + writeFileSync(path.join(outDir, 'yoga-wasm-mvp.js'), header + vendoredGlue); + writeFileSync( + path.join(outDir, 'wrapAssembly.js'), + readUpstream('src/wrapAssembly.js').replaceAll('./generated/YGEnums.js', './YGEnums.js'), + ); + writeFileSync(path.join(outDir, 'YGEnums.js'), readUpstream('src/generated/YGEnums.js')); + + console.log( + `Vendored yoga-layout@${yogaVersion}: ${original.length} -> ${lowered.length} bytes of wasm`, + ); +} finally { + rmSync(tmp, { recursive: true, force: true }); +} diff --git a/packages/plugin-flexbox/src/YogaManager.spec.ts b/packages/plugin-flexbox/src/YogaManager.spec.ts index e271b2d4..95695739 100644 --- a/packages/plugin-flexbox/src/YogaManager.spec.ts +++ b/packages/plugin-flexbox/src/YogaManager.spec.ts @@ -6,7 +6,7 @@ import type { YogaOptions } from './types/YogaOptions'; import { SimpleDataView } from './util/SimpleDataView'; import { YogaManager } from './YogaManager'; -// Mock the yoga-layout/load module +// Mock the vendored yoga loader const mockNode = { create: vi.fn(), free: vi.fn(), @@ -63,7 +63,7 @@ const mockYoga = { DISPLAY_NONE: 1, }; -vi.mock('yoga-layout/load', () => ({ +vi.mock('./yoga/loadYoga', () => ({ loadYoga: vi.fn(() => Promise.resolve(mockYoga)), })); diff --git a/packages/plugin-flexbox/src/YogaManager.ts b/packages/plugin-flexbox/src/YogaManager.ts index 953fdfcc..07b871e8 100644 --- a/packages/plugin-flexbox/src/YogaManager.ts +++ b/packages/plugin-flexbox/src/YogaManager.ts @@ -1,5 +1,5 @@ import { EventEmitter } from 'tseep'; -import { type Config, loadYoga, type Yoga } from 'yoga-layout/load'; +import type { Config, Yoga } from 'yoga-layout/load'; import type { LightningElementStyle, Rect } from '@plextv/react-lightning'; @@ -10,6 +10,7 @@ import type { YogaOptions } from './types/YogaOptions'; import applyReactPropsToYoga, { applyFlexPropToYoga } from './util/applyReactPropsToYoga'; import { resolveHorizontalTranslate, resolveVerticalTranslate } from './util/resolveTranslateInset'; import { SimpleDataView } from './util/SimpleDataView'; +import { loadYoga } from './yoga/loadYoga'; export type BatchedUpdate = Record>; @@ -361,8 +362,9 @@ export class YogaManager { // Microtask runs AFTER the current synchronous batch of style/node // ops (arriving from postMessage handlers); setTimeout's 1ms+ minimum - // would fragment a batch into many render passes. - queueMicrotask(() => { + // would fragment a batch into many render passes. Not queueMicrotask: it + // needs Chrome 71, and nothing polyfills the inline worker. + void Promise.resolve().then(() => { this._isRenderQueued = false; if (this._independentRoots.size === 0) { diff --git a/packages/plugin-flexbox/src/YogaManagerWorker.ts b/packages/plugin-flexbox/src/YogaManagerWorker.ts index a572c75f..1f4a52ab 100644 --- a/packages/plugin-flexbox/src/YogaManagerWorker.ts +++ b/packages/plugin-flexbox/src/YogaManagerWorker.ts @@ -39,7 +39,8 @@ function debounceMicrotask void | Promise { + // Not queueMicrotask, which needs Chrome 71. + void Promise.resolve().then(() => { scheduled = false; fn.apply(this, latestArgs); }); @@ -396,7 +397,7 @@ function resolveFontUrls(yogaOptions?: YogaOptions): YogaOptions | undefined { return yogaOptions; } - const baseHref = globalThis.location?.href; + const baseHref = typeof location === 'undefined' ? undefined : location.href; return { ...yogaOptions, diff --git a/packages/plugin-flexbox/src/util/applyReactPropsToYoga.align.spec.ts b/packages/plugin-flexbox/src/util/applyReactPropsToYoga.align.spec.ts index 2409f2d9..afd2eff1 100644 --- a/packages/plugin-flexbox/src/util/applyReactPropsToYoga.align.spec.ts +++ b/packages/plugin-flexbox/src/util/applyReactPropsToYoga.align.spec.ts @@ -1,11 +1,12 @@ import { beforeAll, describe, expect, it } from 'vitest'; import type { Node } from 'yoga-layout'; -import { loadYoga, type Yoga } from 'yoga-layout/load'; +import type { Yoga } from 'yoga-layout/load'; import type { LightningViewElementStyle } from '@plextv/react-lightning'; import type { ManagerNode } from '../types/ManagerNode'; import type { YogaOptions } from '../types/YogaOptions'; +import { loadYoga } from '../yoga/loadYoga'; import applyReactPropsToYoga, { applyFlexPropToYoga } from './applyReactPropsToYoga'; // Yoga resolves `alignSelf: auto` to the parent's alignItems, and treats diff --git a/packages/plugin-flexbox/src/util/applyReactPropsToYoga.border.spec.ts b/packages/plugin-flexbox/src/util/applyReactPropsToYoga.border.spec.ts index ca2b0016..ffa661e0 100644 --- a/packages/plugin-flexbox/src/util/applyReactPropsToYoga.border.spec.ts +++ b/packages/plugin-flexbox/src/util/applyReactPropsToYoga.border.spec.ts @@ -1,10 +1,11 @@ import { beforeAll, describe, expect, it } from 'vitest'; import type { Node } from 'yoga-layout'; -import { loadYoga, type Yoga } from 'yoga-layout/load'; +import type { Yoga } from 'yoga-layout/load'; import type { LightningViewElementStyle } from '@plextv/react-lightning'; import type { YogaOptions } from '../types/YogaOptions'; +import { loadYoga } from '../yoga/loadYoga'; import { applyFlexPropToYoga } from './applyReactPropsToYoga'; // react-native feeds borderWidth into Yoga (border-box), so a border reserves diff --git a/packages/plugin-flexbox/src/util/applyReactPropsToYoga.minSize.spec.ts b/packages/plugin-flexbox/src/util/applyReactPropsToYoga.minSize.spec.ts index fc1617b4..efd3cf90 100644 --- a/packages/plugin-flexbox/src/util/applyReactPropsToYoga.minSize.spec.ts +++ b/packages/plugin-flexbox/src/util/applyReactPropsToYoga.minSize.spec.ts @@ -1,7 +1,8 @@ import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest'; -import { loadYoga, type Yoga } from 'yoga-layout/load'; +import type { Yoga } from 'yoga-layout/load'; import type { YogaOptions } from '../types/YogaOptions'; +import { loadYoga } from '../yoga/loadYoga'; import { applyFlexPropToYoga } from './applyReactPropsToYoga'; const options = { expandToAutoFlexBasis: false } as YogaOptions; diff --git a/packages/plugin-flexbox/src/util/applyReactPropsToYoga.position.spec.ts b/packages/plugin-flexbox/src/util/applyReactPropsToYoga.position.spec.ts index 3f26cbfa..8ef40795 100644 --- a/packages/plugin-flexbox/src/util/applyReactPropsToYoga.position.spec.ts +++ b/packages/plugin-flexbox/src/util/applyReactPropsToYoga.position.spec.ts @@ -1,10 +1,11 @@ import { beforeAll, describe, expect, it } from 'vitest'; import type { Node } from 'yoga-layout'; -import { loadYoga, type Yoga } from 'yoga-layout/load'; +import type { Yoga } from 'yoga-layout/load'; import type { LightningViewElementStyle } from '@plextv/react-lightning'; import type { YogaOptions } from '../types/YogaOptions'; +import { loadYoga } from '../yoga/loadYoga'; import { applyFlexPropToYoga } from './applyReactPropsToYoga'; // RN ships logical start/end insets (LTR: start=left, end=right). react-lightning diff --git a/packages/plugin-flexbox/src/yoga/loadYoga.ts b/packages/plugin-flexbox/src/yoga/loadYoga.ts new file mode 100644 index 00000000..57279c99 --- /dev/null +++ b/packages/plugin-flexbox/src/yoga/loadYoga.ts @@ -0,0 +1,12 @@ +import type { Yoga } from 'yoga-layout/load'; + +import wrapAssembly from './vendor/wrapAssembly.js'; +import loadYogaImpl from './vendor/yoga-wasm-mvp.js'; + +/** + * Same as `loadYoga` from `yoga-layout/load`, but with the wasm lowered to + * WebAssembly MVP so it runs on Chrome 57+ (the upstream build needs 74). + */ +export async function loadYoga(): Promise { + return wrapAssembly(await loadYogaImpl()); +} diff --git a/packages/plugin-flexbox/src/yoga/vendor/YGEnums.js b/packages/plugin-flexbox/src/yoga/vendor/YGEnums.js new file mode 100644 index 00000000..00afc114 --- /dev/null +++ b/packages/plugin-flexbox/src/yoga/vendor/YGEnums.js @@ -0,0 +1,210 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// @generated by enums.py + +export let Align = /*#__PURE__*/function (Align) { + Align[Align["Auto"] = 0] = "Auto"; + Align[Align["FlexStart"] = 1] = "FlexStart"; + Align[Align["Center"] = 2] = "Center"; + Align[Align["FlexEnd"] = 3] = "FlexEnd"; + Align[Align["Stretch"] = 4] = "Stretch"; + Align[Align["Baseline"] = 5] = "Baseline"; + Align[Align["SpaceBetween"] = 6] = "SpaceBetween"; + Align[Align["SpaceAround"] = 7] = "SpaceAround"; + Align[Align["SpaceEvenly"] = 8] = "SpaceEvenly"; + return Align; +}({}); +export let BoxSizing = /*#__PURE__*/function (BoxSizing) { + BoxSizing[BoxSizing["BorderBox"] = 0] = "BorderBox"; + BoxSizing[BoxSizing["ContentBox"] = 1] = "ContentBox"; + return BoxSizing; +}({}); +export let Dimension = /*#__PURE__*/function (Dimension) { + Dimension[Dimension["Width"] = 0] = "Width"; + Dimension[Dimension["Height"] = 1] = "Height"; + return Dimension; +}({}); +export let Direction = /*#__PURE__*/function (Direction) { + Direction[Direction["Inherit"] = 0] = "Inherit"; + Direction[Direction["LTR"] = 1] = "LTR"; + Direction[Direction["RTL"] = 2] = "RTL"; + return Direction; +}({}); +export let Display = /*#__PURE__*/function (Display) { + Display[Display["Flex"] = 0] = "Flex"; + Display[Display["None"] = 1] = "None"; + Display[Display["Contents"] = 2] = "Contents"; + return Display; +}({}); +export let Edge = /*#__PURE__*/function (Edge) { + Edge[Edge["Left"] = 0] = "Left"; + Edge[Edge["Top"] = 1] = "Top"; + Edge[Edge["Right"] = 2] = "Right"; + Edge[Edge["Bottom"] = 3] = "Bottom"; + Edge[Edge["Start"] = 4] = "Start"; + Edge[Edge["End"] = 5] = "End"; + Edge[Edge["Horizontal"] = 6] = "Horizontal"; + Edge[Edge["Vertical"] = 7] = "Vertical"; + Edge[Edge["All"] = 8] = "All"; + return Edge; +}({}); +export let Errata = /*#__PURE__*/function (Errata) { + Errata[Errata["None"] = 0] = "None"; + Errata[Errata["StretchFlexBasis"] = 1] = "StretchFlexBasis"; + Errata[Errata["AbsolutePositionWithoutInsetsExcludesPadding"] = 2] = "AbsolutePositionWithoutInsetsExcludesPadding"; + Errata[Errata["AbsolutePercentAgainstInnerSize"] = 4] = "AbsolutePercentAgainstInnerSize"; + Errata[Errata["All"] = 2147483647] = "All"; + Errata[Errata["Classic"] = 2147483646] = "Classic"; + return Errata; +}({}); +export let ExperimentalFeature = /*#__PURE__*/function (ExperimentalFeature) { + ExperimentalFeature[ExperimentalFeature["WebFlexBasis"] = 0] = "WebFlexBasis"; + return ExperimentalFeature; +}({}); +export let FlexDirection = /*#__PURE__*/function (FlexDirection) { + FlexDirection[FlexDirection["Column"] = 0] = "Column"; + FlexDirection[FlexDirection["ColumnReverse"] = 1] = "ColumnReverse"; + FlexDirection[FlexDirection["Row"] = 2] = "Row"; + FlexDirection[FlexDirection["RowReverse"] = 3] = "RowReverse"; + return FlexDirection; +}({}); +export let Gutter = /*#__PURE__*/function (Gutter) { + Gutter[Gutter["Column"] = 0] = "Column"; + Gutter[Gutter["Row"] = 1] = "Row"; + Gutter[Gutter["All"] = 2] = "All"; + return Gutter; +}({}); +export let Justify = /*#__PURE__*/function (Justify) { + Justify[Justify["FlexStart"] = 0] = "FlexStart"; + Justify[Justify["Center"] = 1] = "Center"; + Justify[Justify["FlexEnd"] = 2] = "FlexEnd"; + Justify[Justify["SpaceBetween"] = 3] = "SpaceBetween"; + Justify[Justify["SpaceAround"] = 4] = "SpaceAround"; + Justify[Justify["SpaceEvenly"] = 5] = "SpaceEvenly"; + return Justify; +}({}); +export let LogLevel = /*#__PURE__*/function (LogLevel) { + LogLevel[LogLevel["Error"] = 0] = "Error"; + LogLevel[LogLevel["Warn"] = 1] = "Warn"; + LogLevel[LogLevel["Info"] = 2] = "Info"; + LogLevel[LogLevel["Debug"] = 3] = "Debug"; + LogLevel[LogLevel["Verbose"] = 4] = "Verbose"; + LogLevel[LogLevel["Fatal"] = 5] = "Fatal"; + return LogLevel; +}({}); +export let MeasureMode = /*#__PURE__*/function (MeasureMode) { + MeasureMode[MeasureMode["Undefined"] = 0] = "Undefined"; + MeasureMode[MeasureMode["Exactly"] = 1] = "Exactly"; + MeasureMode[MeasureMode["AtMost"] = 2] = "AtMost"; + return MeasureMode; +}({}); +export let NodeType = /*#__PURE__*/function (NodeType) { + NodeType[NodeType["Default"] = 0] = "Default"; + NodeType[NodeType["Text"] = 1] = "Text"; + return NodeType; +}({}); +export let Overflow = /*#__PURE__*/function (Overflow) { + Overflow[Overflow["Visible"] = 0] = "Visible"; + Overflow[Overflow["Hidden"] = 1] = "Hidden"; + Overflow[Overflow["Scroll"] = 2] = "Scroll"; + return Overflow; +}({}); +export let PositionType = /*#__PURE__*/function (PositionType) { + PositionType[PositionType["Static"] = 0] = "Static"; + PositionType[PositionType["Relative"] = 1] = "Relative"; + PositionType[PositionType["Absolute"] = 2] = "Absolute"; + return PositionType; +}({}); +export let Unit = /*#__PURE__*/function (Unit) { + Unit[Unit["Undefined"] = 0] = "Undefined"; + Unit[Unit["Point"] = 1] = "Point"; + Unit[Unit["Percent"] = 2] = "Percent"; + Unit[Unit["Auto"] = 3] = "Auto"; + return Unit; +}({}); +export let Wrap = /*#__PURE__*/function (Wrap) { + Wrap[Wrap["NoWrap"] = 0] = "NoWrap"; + Wrap[Wrap["Wrap"] = 1] = "Wrap"; + Wrap[Wrap["WrapReverse"] = 2] = "WrapReverse"; + return Wrap; +}({}); +const constants = { + ALIGN_AUTO: Align.Auto, + ALIGN_FLEX_START: Align.FlexStart, + ALIGN_CENTER: Align.Center, + ALIGN_FLEX_END: Align.FlexEnd, + ALIGN_STRETCH: Align.Stretch, + ALIGN_BASELINE: Align.Baseline, + ALIGN_SPACE_BETWEEN: Align.SpaceBetween, + ALIGN_SPACE_AROUND: Align.SpaceAround, + ALIGN_SPACE_EVENLY: Align.SpaceEvenly, + BOX_SIZING_BORDER_BOX: BoxSizing.BorderBox, + BOX_SIZING_CONTENT_BOX: BoxSizing.ContentBox, + DIMENSION_WIDTH: Dimension.Width, + DIMENSION_HEIGHT: Dimension.Height, + DIRECTION_INHERIT: Direction.Inherit, + DIRECTION_LTR: Direction.LTR, + DIRECTION_RTL: Direction.RTL, + DISPLAY_FLEX: Display.Flex, + DISPLAY_NONE: Display.None, + DISPLAY_CONTENTS: Display.Contents, + EDGE_LEFT: Edge.Left, + EDGE_TOP: Edge.Top, + EDGE_RIGHT: Edge.Right, + EDGE_BOTTOM: Edge.Bottom, + EDGE_START: Edge.Start, + EDGE_END: Edge.End, + EDGE_HORIZONTAL: Edge.Horizontal, + EDGE_VERTICAL: Edge.Vertical, + EDGE_ALL: Edge.All, + ERRATA_NONE: Errata.None, + ERRATA_STRETCH_FLEX_BASIS: Errata.StretchFlexBasis, + ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING: Errata.AbsolutePositionWithoutInsetsExcludesPadding, + ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE: Errata.AbsolutePercentAgainstInnerSize, + ERRATA_ALL: Errata.All, + ERRATA_CLASSIC: Errata.Classic, + EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS: ExperimentalFeature.WebFlexBasis, + FLEX_DIRECTION_COLUMN: FlexDirection.Column, + FLEX_DIRECTION_COLUMN_REVERSE: FlexDirection.ColumnReverse, + FLEX_DIRECTION_ROW: FlexDirection.Row, + FLEX_DIRECTION_ROW_REVERSE: FlexDirection.RowReverse, + GUTTER_COLUMN: Gutter.Column, + GUTTER_ROW: Gutter.Row, + GUTTER_ALL: Gutter.All, + JUSTIFY_FLEX_START: Justify.FlexStart, + JUSTIFY_CENTER: Justify.Center, + JUSTIFY_FLEX_END: Justify.FlexEnd, + JUSTIFY_SPACE_BETWEEN: Justify.SpaceBetween, + JUSTIFY_SPACE_AROUND: Justify.SpaceAround, + JUSTIFY_SPACE_EVENLY: Justify.SpaceEvenly, + LOG_LEVEL_ERROR: LogLevel.Error, + LOG_LEVEL_WARN: LogLevel.Warn, + LOG_LEVEL_INFO: LogLevel.Info, + LOG_LEVEL_DEBUG: LogLevel.Debug, + LOG_LEVEL_VERBOSE: LogLevel.Verbose, + LOG_LEVEL_FATAL: LogLevel.Fatal, + MEASURE_MODE_UNDEFINED: MeasureMode.Undefined, + MEASURE_MODE_EXACTLY: MeasureMode.Exactly, + MEASURE_MODE_AT_MOST: MeasureMode.AtMost, + NODE_TYPE_DEFAULT: NodeType.Default, + NODE_TYPE_TEXT: NodeType.Text, + OVERFLOW_VISIBLE: Overflow.Visible, + OVERFLOW_HIDDEN: Overflow.Hidden, + OVERFLOW_SCROLL: Overflow.Scroll, + POSITION_TYPE_STATIC: PositionType.Static, + POSITION_TYPE_RELATIVE: PositionType.Relative, + POSITION_TYPE_ABSOLUTE: PositionType.Absolute, + UNIT_UNDEFINED: Unit.Undefined, + UNIT_POINT: Unit.Point, + UNIT_PERCENT: Unit.Percent, + UNIT_AUTO: Unit.Auto, + WRAP_NO_WRAP: Wrap.NoWrap, + WRAP_WRAP: Wrap.Wrap, + WRAP_WRAP_REVERSE: Wrap.WrapReverse +}; +export default constants; diff --git a/packages/plugin-flexbox/src/yoga/vendor/wrapAssembly.d.ts b/packages/plugin-flexbox/src/yoga/vendor/wrapAssembly.d.ts new file mode 100644 index 00000000..46e43aba --- /dev/null +++ b/packages/plugin-flexbox/src/yoga/vendor/wrapAssembly.d.ts @@ -0,0 +1,5 @@ +import type { Yoga } from 'yoga-layout/load'; + +declare function wrapAssembly(lib: unknown): Yoga; + +export default wrapAssembly; diff --git a/packages/plugin-flexbox/src/yoga/vendor/wrapAssembly.js b/packages/plugin-flexbox/src/yoga/vendor/wrapAssembly.js new file mode 100644 index 00000000..41641714 --- /dev/null +++ b/packages/plugin-flexbox/src/yoga/vendor/wrapAssembly.js @@ -0,0 +1,124 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @format + */ + +// @ts-nocheck + +import { Unit, Direction } from "./YGEnums.js"; +import YGEnums from "./YGEnums.js"; +// eslint-disable-next-line @typescript-eslint/no-explicit-any +export default function wrapAssembly(lib) { + function patch(prototype, name, fn) { + const original = prototype[name]; + prototype[name] = function () { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return fn.call(this, original, ...args); + }; + } + for (const fnName of ['setPosition', 'setMargin', 'setFlexBasis', 'setWidth', 'setHeight', 'setMinWidth', 'setMinHeight', 'setMaxWidth', 'setMaxHeight', 'setPadding', 'setGap']) { + const methods = { + [Unit.Point]: lib.Node.prototype[fnName], + [Unit.Percent]: lib.Node.prototype[`${fnName}Percent`], + [Unit.Auto]: lib.Node.prototype[`${fnName}Auto`] + }; + patch(lib.Node.prototype, fnName, function (original) { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + // We patch all these functions to add support for the following calls: + // .setWidth(100) / .setWidth("100%") / .setWidth(.getWidth()) / .setWidth("auto") + + const value = args.pop(); + let unit, asNumber; + if (value === 'auto') { + unit = Unit.Auto; + asNumber = undefined; + } else if (typeof value === 'object') { + unit = value.unit; + asNumber = value.valueOf(); + } else { + unit = typeof value === 'string' && value.endsWith('%') ? Unit.Percent : Unit.Point; + asNumber = parseFloat(value); + if (value !== undefined && !Number.isNaN(value) && Number.isNaN(asNumber)) { + throw new Error(`Invalid value ${value} for ${fnName}`); + } + } + if (!methods[unit]) throw new Error(`Failed to execute "${fnName}": Unsupported unit '${value}'`); + if (asNumber !== undefined) { + return methods[unit].call(this, ...args, asNumber); + } else { + return methods[unit].call(this, ...args); + } + }); + } + function wrapMeasureFunction(measureFunction) { + return lib.MeasureCallback.implement({ + measure: function () { + const { + width, + height + } = measureFunction(...arguments); + return { + width: width ?? NaN, + height: height ?? NaN + }; + } + }); + } + patch(lib.Node.prototype, 'setMeasureFunc', function (original, measureFunc) { + // This patch is just a convenience patch, since it helps write more + // idiomatic source code (such as .setMeasureFunc(null)) + if (measureFunc) { + return original.call(this, wrapMeasureFunction(measureFunc)); + } else { + return this.unsetMeasureFunc(); + } + }); + function wrapDirtiedFunc(dirtiedFunction) { + return lib.DirtiedCallback.implement({ + dirtied: dirtiedFunction + }); + } + patch(lib.Node.prototype, 'setDirtiedFunc', function (original, dirtiedFunc) { + original.call(this, wrapDirtiedFunc(dirtiedFunc)); + }); + patch(lib.Config.prototype, 'free', function () { + // Since we handle the memory allocation ourselves (via lib.Config.create), + // we also need to handle the deallocation + lib.Config.destroy(this); + }); + patch(lib.Node, 'create', (_, config) => { + // We decide the constructor we want to call depending on the parameters + return config ? lib.Node.createWithConfig(config) : lib.Node.createDefault(); + }); + patch(lib.Node.prototype, 'free', function () { + // Since we handle the memory allocation ourselves (via lib.Node.create), + // we also need to handle the deallocation + lib.Node.destroy(this); + }); + patch(lib.Node.prototype, 'freeRecursive', function () { + for (let t = 0, T = this.getChildCount(); t < T; ++t) { + this.getChild(0).freeRecursive(); + } + this.free(); + }); + patch(lib.Node.prototype, 'calculateLayout', function (original) { + let width = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : NaN; + let height = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : NaN; + let direction = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : Direction.LTR; + // Just a small patch to add support for the function default parameters + return original.call(this, width, height, direction); + }); + return { + Config: lib.Config, + Node: lib.Node, + ...YGEnums + }; +} diff --git a/packages/plugin-flexbox/src/yoga/vendor/yoga-wasm-mvp.d.ts b/packages/plugin-flexbox/src/yoga/vendor/yoga-wasm-mvp.d.ts new file mode 100644 index 00000000..e8c7d11f --- /dev/null +++ b/packages/plugin-flexbox/src/yoga/vendor/yoga-wasm-mvp.d.ts @@ -0,0 +1,3 @@ +declare function loadYogaImpl(): Promise; + +export default loadYogaImpl; diff --git a/packages/plugin-flexbox/src/yoga/vendor/yoga-wasm-mvp.js b/packages/plugin-flexbox/src/yoga/vendor/yoga-wasm-mvp.js new file mode 100644 index 00000000..7d6d0ff6 --- /dev/null +++ b/packages/plugin-flexbox/src/yoga/vendor/yoga-wasm-mvp.js @@ -0,0 +1,78 @@ +// Generated by scripts/vendorYoga.ts from yoga-layout@3.2.1 (MIT, Meta Platforms, Inc.). Do not edit. +// The wasm is lowered to WebAssembly MVP with binaryen@132.0.0 (--signext-lowering). +// source-wasm-sha256: 7ba9c9483c8c38a468e9aef4a95ed72fad8a43594be8e5123eb3bdb6479edf5b + +var loadYoga = (() => { + var _scriptDir = ""; + + return ( +function(loadYoga) { + loadYoga = loadYoga || {}; + + +var h;h||(h=typeof loadYoga !== 'undefined' ? loadYoga : {});var aa,ca;h.ready=new Promise(function(a,b){aa=a;ca=b});var da=Object.assign({},h),q="";"undefined"!=typeof document&&document.currentScript&&(q=document.currentScript.src);_scriptDir&&(q=_scriptDir);0!==q.indexOf("blob:")?q=q.substr(0,q.replace(/[?#].*/,"").lastIndexOf("/")+1):q="";var ea=h.print||console.log.bind(console),v=h.printErr||console.warn.bind(console);Object.assign(h,da);da=null;var w;h.wasmBinary&&(w=h.wasmBinary); +var noExitRuntime=h.noExitRuntime||!0;"object"!=typeof WebAssembly&&x("no native wasm support detected");var fa,ha=!1;function z(a,b,c){c=b+c;for(var d="";!(b>=c);){var e=a[b++];if(!e)break;if(e&128){var f=a[b++]&63;if(192==(e&224))d+=String.fromCharCode((e&31)<<6|f);else{var g=a[b++]&63;e=224==(e&240)?(e&15)<<12|f<<6|g:(e&7)<<18|f<<12|g<<6|a[b++]&63;65536>e?d+=String.fromCharCode(e):(e-=65536,d+=String.fromCharCode(55296|e>>10,56320|e&1023))}}else d+=String.fromCharCode(e)}return d} +var ia,ja,A,C,ka,D,E,la,ma;function na(){var a=fa.buffer;ia=a;h.HEAP8=ja=new Int8Array(a);h.HEAP16=C=new Int16Array(a);h.HEAP32=D=new Int32Array(a);h.HEAPU8=A=new Uint8Array(a);h.HEAPU16=ka=new Uint16Array(a);h.HEAPU32=E=new Uint32Array(a);h.HEAPF32=la=new Float32Array(a);h.HEAPF64=ma=new Float64Array(a)}var oa,pa=[],qa=[],ra=[];function sa(){var a=h.preRun.shift();pa.unshift(a)}var F=0,ta=null,G=null; +function x(a){if(h.onAbort)h.onAbort(a);a="Aborted("+a+")";v(a);ha=!0;a=new WebAssembly.RuntimeError(a+". Build with -sASSERTIONS for more info.");ca(a);throw a;}function ua(a){return a.startsWith("data:application/octet-stream;base64,")}var H;H="data:application/octet-stream;base64,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";if(!ua(H)){var va=H;H=h.locateFile?h.locateFile(va,q):q+va} +function wa(){var a=H;try{if(a==H&&w)return new Uint8Array(w);if(ua(a))try{var b=xa(a.slice(37)),c=new Uint8Array(b.length);for(a=0;a=b?"_"+a:a} +function Ba(a,b){a=Aa(a);return function(){return b.apply(this,arguments)}}var J=[{},{value:void 0},{value:null},{value:!0},{value:!1}],Ca=[];function Da(a){var b=Error,c=Ba(a,function(d){this.name=a;this.message=d;d=Error(d).stack;void 0!==d&&(this.stack=this.toString()+"\n"+d.replace(/^Error(:[^\n]*)?\n/,""))});c.prototype=Object.create(b.prototype);c.prototype.constructor=c;c.prototype.toString=function(){return void 0===this.message?this.name:this.name+": "+this.message};return c}var K=void 0; +function L(a){throw new K(a);}var M=a=>{a||L("Cannot use deleted val. handle = "+a);return J[a].value},Ea=a=>{switch(a){case void 0:return 1;case null:return 2;case !0:return 3;case !1:return 4;default:var b=Ca.length?Ca.pop():J.length;J[b]={ga:1,value:a};return b}},Fa=void 0,Ga=void 0;function N(a){for(var b="";A[a];)b+=Ga[A[a++]];return b}var O=[];function Ha(){for(;O.length;){var a=O.pop();a.M.$=!1;a["delete"]()}}var P=void 0,Q={}; +function Ia(a,b){for(void 0===b&&L("ptr should not be undefined");a.R;)b=a.ba(b),a=a.R;return b}var R={};function Ja(a){a=Ka(a);var b=N(a);S(a);return b}function La(a,b){var c=R[a];void 0===c&&L(b+" has unknown type "+Ja(a));return c}function Ma(){}var Na=!1;function Oa(a){--a.count.value;0===a.count.value&&(a.T?a.U.W(a.T):a.P.N.W(a.O))}function Pa(a,b,c){if(b===c)return a;if(void 0===c.R)return null;a=Pa(a,b,c.R);return null===a?null:c.na(a)}var Qa={};function Ra(a,b){b=Ia(a,b);return Q[b]} +var Sa=void 0;function Ta(a){throw new Sa(a);}function Ua(a,b){b.P&&b.O||Ta("makeClassHandle requires ptr and ptrType");!!b.U!==!!b.T&&Ta("Both smartPtrType and smartPtr must be specified");b.count={value:1};return T(Object.create(a,{M:{value:b}}))}function T(a){if("undefined"===typeof FinalizationRegistry)return T=b=>b,a;Na=new FinalizationRegistry(b=>{Oa(b.M)});T=b=>{var c=b.M;c.T&&Na.register(b,{M:c},b);return b};Ma=b=>{Na.unregister(b)};return T(a)}var Va={}; +function Wa(a){for(;a.length;){var b=a.pop();a.pop()(b)}}function Xa(a){return this.fromWireType(D[a>>2])}var U={},Ya={};function V(a,b,c){function d(k){k=c(k);k.length!==a.length&&Ta("Mismatched type converter count");for(var m=0;m{R.hasOwnProperty(k)?e[m]=R[k]:(f.push(k),U.hasOwnProperty(k)||(U[k]=[]),U[k].push(()=>{e[m]=R[k];++g;g===f.length&&d(e)}))});0===f.length&&d(e)} +function Za(a){switch(a){case 1:return 0;case 2:return 1;case 4:return 2;case 8:return 3;default:throw new TypeError("Unknown type size: "+a);}} +function W(a,b,c={}){if(!("argPackAdvance"in b))throw new TypeError("registerType registeredInstance requires argPackAdvance");var d=b.name;a||L('type "'+d+'" must have a positive integer typeid pointer');if(R.hasOwnProperty(a)){if(c.ua)return;L("Cannot register type '"+d+"' twice")}R[a]=b;delete Ya[a];U.hasOwnProperty(a)&&(b=U[a],delete U[a],b.forEach(e=>e()))}function $a(a){L(a.M.P.N.name+" instance already deleted")}function X(){} +function ab(a,b,c){if(void 0===a[b].S){var d=a[b];a[b]=function(){a[b].S.hasOwnProperty(arguments.length)||L("Function '"+c+"' called with an invalid number of arguments ("+arguments.length+") - expects one of ("+a[b].S+")!");return a[b].S[arguments.length].apply(this,arguments)};a[b].S=[];a[b].S[d.Z]=d}} +function bb(a,b){h.hasOwnProperty(a)?(L("Cannot register public name '"+a+"' twice"),ab(h,a,a),h.hasOwnProperty(void 0)&&L("Cannot register multiple overloads of a function with the same number of arguments (undefined)!"),h[a].S[void 0]=b):h[a]=b}function cb(a,b,c,d,e,f,g,k){this.name=a;this.constructor=b;this.X=c;this.W=d;this.R=e;this.pa=f;this.ba=g;this.na=k;this.ja=[]} +function db(a,b,c){for(;b!==c;)b.ba||L("Expected null or instance of "+c.name+", got an instance of "+b.name),a=b.ba(a),b=b.R;return a}function eb(a,b){if(null===b)return this.ea&&L("null is not a valid "+this.name),0;b.M||L('Cannot pass "'+fb(b)+'" as a '+this.name);b.M.O||L("Cannot pass deleted object as a pointer of type "+this.name);return db(b.M.O,b.M.P.N,this.N)} +function gb(a,b){if(null===b){this.ea&&L("null is not a valid "+this.name);if(this.da){var c=this.fa();null!==a&&a.push(this.W,c);return c}return 0}b.M||L('Cannot pass "'+fb(b)+'" as a '+this.name);b.M.O||L("Cannot pass deleted object as a pointer of type "+this.name);!this.ca&&b.M.P.ca&&L("Cannot convert argument of type "+(b.M.U?b.M.U.name:b.M.P.name)+" to parameter type "+this.name);c=db(b.M.O,b.M.P.N,this.N);if(this.da)switch(void 0===b.M.T&&L("Passing raw pointer to smart pointer is illegal"), +this.Ba){case 0:b.M.U===this?c=b.M.T:L("Cannot convert argument of type "+(b.M.U?b.M.U.name:b.M.P.name)+" to parameter type "+this.name);break;case 1:c=b.M.T;break;case 2:if(b.M.U===this)c=b.M.T;else{var d=b.clone();c=this.xa(c,Ea(function(){d["delete"]()}));null!==a&&a.push(this.W,c)}break;default:L("Unsupporting sharing policy")}return c} +function hb(a,b){if(null===b)return this.ea&&L("null is not a valid "+this.name),0;b.M||L('Cannot pass "'+fb(b)+'" as a '+this.name);b.M.O||L("Cannot pass deleted object as a pointer of type "+this.name);b.M.P.ca&&L("Cannot convert argument of type "+b.M.P.name+" to parameter type "+this.name);return db(b.M.O,b.M.P.N,this.N)} +function Y(a,b,c,d){this.name=a;this.N=b;this.ea=c;this.ca=d;this.da=!1;this.W=this.xa=this.fa=this.ka=this.Ba=this.wa=void 0;void 0!==b.R?this.toWireType=gb:(this.toWireType=d?eb:hb,this.V=null)}function ib(a,b){h.hasOwnProperty(a)||Ta("Replacing nonexistant public symbol");h[a]=b;h[a].Z=void 0} +function jb(a,b){var c=[];return function(){c.length=0;Object.assign(c,arguments);if(a.includes("j")){var d=h["dynCall_"+a];d=c&&c.length?d.apply(null,[b].concat(c)):d.call(null,b)}else d=oa.get(b).apply(null,c);return d}}function Z(a,b){a=N(a);var c=a.includes("j")?jb(a,b):oa.get(b);"function"!=typeof c&&L("unknown function pointer with signature "+a+": "+b);return c}var mb=void 0; +function nb(a,b){function c(f){e[f]||R[f]||(Ya[f]?Ya[f].forEach(c):(d.push(f),e[f]=!0))}var d=[],e={};b.forEach(c);throw new mb(a+": "+d.map(Ja).join([", "]));} +function ob(a,b,c,d,e){var f=b.length;2>f&&L("argTypes array size mismatch! Must at least get return value and 'this' types!");var g=null!==b[1]&&null!==c,k=!1;for(c=1;c>2]);return c}function qb(a){4>2])};case 3:return function(c){return this.fromWireType(ma[c>>3])};default:throw new TypeError("Unknown float type: "+a);}} +function sb(a,b,c){switch(b){case 0:return c?function(d){return ja[d]}:function(d){return A[d]};case 1:return c?function(d){return C[d>>1]}:function(d){return ka[d>>1]};case 2:return c?function(d){return D[d>>2]}:function(d){return E[d>>2]};default:throw new TypeError("Unknown integer type: "+a);}}function tb(a,b){for(var c="",d=0;!(d>=b/2);++d){var e=C[a+2*d>>1];if(0==e)break;c+=String.fromCharCode(e)}return c} +function ub(a,b,c){void 0===c&&(c=2147483647);if(2>c)return 0;c-=2;var d=b;c=c<2*a.length?c/2:a.length;for(var e=0;e>1]=a.charCodeAt(e),b+=2;C[b>>1]=0;return b-d}function vb(a){return 2*a.length}function wb(a,b){for(var c=0,d="";!(c>=b/4);){var e=D[a+4*c>>2];if(0==e)break;++c;65536<=e?(e-=65536,d+=String.fromCharCode(55296|e>>10,56320|e&1023)):d+=String.fromCharCode(e)}return d} +function xb(a,b,c){void 0===c&&(c=2147483647);if(4>c)return 0;var d=b;c=d+c-4;for(var e=0;e=f){var g=a.charCodeAt(++e);f=65536+((f&1023)<<10)|g&1023}D[b>>2]=f;b+=4;if(b+4>c)break}D[b>>2]=0;return b-d}function yb(a){for(var b=0,c=0;c=d&&++c;b+=4}return b}var zb={};function Ab(a){var b=zb[a];return void 0===b?N(a):b}var Bb=[];function Cb(a){var b=Bb.length;Bb.push(a);return b} +function Db(a,b){for(var c=Array(a),d=0;d>2],"parameter "+d);return c}var Eb=[],Fb=[null,[],[]];K=h.BindingError=Da("BindingError");h.count_emval_handles=function(){for(var a=0,b=5;bHb;++Hb)Gb[Hb]=String.fromCharCode(Hb);Ga=Gb;h.getInheritedInstanceCount=function(){return Object.keys(Q).length}; +h.getLiveInheritedInstances=function(){var a=[],b;for(b in Q)Q.hasOwnProperty(b)&&a.push(Q[b]);return a};h.flushPendingDeletes=Ha;h.setDelayFunction=function(a){P=a;O.length&&P&&P(Ha)};Sa=h.InternalError=Da("InternalError");X.prototype.isAliasOf=function(a){if(!(this instanceof X&&a instanceof X))return!1;var b=this.M.P.N,c=this.M.O,d=a.M.P.N;for(a=a.M.O;b.R;)c=b.ba(c),b=b.R;for(;d.R;)a=d.ba(a),d=d.R;return b===d&&c===a}; +X.prototype.clone=function(){this.M.O||$a(this);if(this.M.aa)return this.M.count.value+=1,this;var a=T,b=Object,c=b.create,d=Object.getPrototypeOf(this),e=this.M;a=a(c.call(b,d,{M:{value:{count:e.count,$:e.$,aa:e.aa,O:e.O,P:e.P,T:e.T,U:e.U}}}));a.M.count.value+=1;a.M.$=!1;return a};X.prototype["delete"]=function(){this.M.O||$a(this);this.M.$&&!this.M.aa&&L("Object already scheduled for deletion");Ma(this);Oa(this.M);this.M.aa||(this.M.T=void 0,this.M.O=void 0)};X.prototype.isDeleted=function(){return!this.M.O}; +X.prototype.deleteLater=function(){this.M.O||$a(this);this.M.$&&!this.M.aa&&L("Object already scheduled for deletion");O.push(this);1===O.length&&P&&P(Ha);this.M.$=!0;return this};Y.prototype.qa=function(a){this.ka&&(a=this.ka(a));return a};Y.prototype.ha=function(a){this.W&&this.W(a)};Y.prototype.argPackAdvance=8;Y.prototype.readValueFromPointer=Xa;Y.prototype.deleteObject=function(a){if(null!==a)a["delete"]()}; +Y.prototype.fromWireType=function(a){function b(){return this.da?Ua(this.N.X,{P:this.wa,O:c,U:this,T:a}):Ua(this.N.X,{P:this,O:a})}var c=this.qa(a);if(!c)return this.ha(a),null;var d=Ra(this.N,c);if(void 0!==d){if(0===d.M.count.value)return d.M.O=c,d.M.T=a,d.clone();d=d.clone();this.ha(a);return d}d=this.N.pa(c);d=Qa[d];if(!d)return b.call(this);d=this.ca?d.la:d.pointerType;var e=Pa(c,this.N,d.N);return null===e?b.call(this):this.da?Ua(d.N.X,{P:d,O:e,U:this,T:a}):Ua(d.N.X,{P:d,O:e})}; +mb=h.UnboundTypeError=Da("UnboundTypeError"); +var xa="function"==typeof atob?atob:function(a){var b="",c=0;a=a.replace(/[^A-Za-z0-9\+\/=]/g,"");do{var d="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(a.charAt(c++));var e="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(a.charAt(c++));var f="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(a.charAt(c++));var g="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(a.charAt(c++));d=d<<2|e>>4; +e=(e&15)<<4|f>>2;var k=(f&3)<<6|g;b+=String.fromCharCode(d);64!==f&&(b+=String.fromCharCode(e));64!==g&&(b+=String.fromCharCode(k))}while(cg.ta).concat(e.map(g=>g.za));V([a],f,g=>{var k={};e.forEach((m,l)=>{var n=g[l],p=m.ra,r=m.sa,u=g[l+e.length],t=m.ya,y=m.Aa;k[m.oa]={read:B=>n.fromWireType(p(r,B)),write:(B,ba)=>{var I=[];t(y, +B,u.toWireType(I,ba));Wa(I)}}});return[{name:b.name,fromWireType:function(m){var l={},n;for(n in k)l[n]=k[n].read(m);d(m);return l},toWireType:function(m,l){for(var n in k)if(!(n in l))throw new TypeError('Missing field: "'+n+'"');var p=c();for(n in k)k[n].write(p,l[n]);null!==m&&m.push(d,p);return p},argPackAdvance:8,readValueFromPointer:Xa,V:d}]})},v:function(){},B:function(a,b,c,d,e){var f=Za(c);b=N(b);W(a,{name:b,fromWireType:function(g){return!!g},toWireType:function(g,k){return k?d:e},argPackAdvance:8, +readValueFromPointer:function(g){if(1===c)var k=ja;else if(2===c)k=C;else if(4===c)k=D;else throw new TypeError("Unknown boolean type size: "+b);return this.fromWireType(k[g>>f])},V:null})},f:function(a,b,c,d,e,f,g,k,m,l,n,p,r){n=N(n);f=Z(e,f);k&&(k=Z(g,k));l&&(l=Z(m,l));r=Z(p,r);var u=Aa(n);bb(u,function(){nb("Cannot construct "+n+" due to unbound types",[d])});V([a,b,c],d?[d]:[],function(t){t=t[0];if(d){var y=t.N;var B=y.X}else B=X.prototype;t=Ba(u,function(){if(Object.getPrototypeOf(this)!==ba)throw new K("Use 'new' to construct "+ +n);if(void 0===I.Y)throw new K(n+" has no accessible constructor");var kb=I.Y[arguments.length];if(void 0===kb)throw new K("Tried to invoke ctor of "+n+" with invalid number of parameters ("+arguments.length+") - expected ("+Object.keys(I.Y).toString()+") parameters instead!");return kb.apply(this,arguments)});var ba=Object.create(B,{constructor:{value:t}});t.prototype=ba;var I=new cb(n,t,ba,r,y,f,k,l);y=new Y(n,I,!0,!1);B=new Y(n+"*",I,!1,!1);var lb=new Y(n+" const*",I,!1,!0);Qa[a]={pointerType:B, +la:lb};ib(u,t);return[y,B,lb]})},d:function(a,b,c,d,e,f,g){var k=pb(c,d);b=N(b);f=Z(e,f);V([],[a],function(m){function l(){nb("Cannot call "+n+" due to unbound types",k)}m=m[0];var n=m.name+"."+b;b.startsWith("@@")&&(b=Symbol[b.substring(2)]);var p=m.N.constructor;void 0===p[b]?(l.Z=c-1,p[b]=l):(ab(p,b,n),p[b].S[c-1]=l);V([],k,function(r){r=ob(n,[r[0],null].concat(r.slice(1)),null,f,g);void 0===p[b].S?(r.Z=c-1,p[b]=r):p[b].S[c-1]=r;return[]});return[]})},p:function(a,b,c,d,e,f){0{nb("Cannot construct "+k.name+" due to unbound types",g)};V([],g,function(l){l.splice(1,0,null);k.N.Y[b-1]=ob(m,l,null,e,f);return[]});return[]})}, +a:function(a,b,c,d,e,f,g,k){var m=pb(c,d);b=N(b);f=Z(e,f);V([],[a],function(l){function n(){nb("Cannot call "+p+" due to unbound types",m)}l=l[0];var p=l.name+"."+b;b.startsWith("@@")&&(b=Symbol[b.substring(2)]);k&&l.N.ja.push(b);var r=l.N.X,u=r[b];void 0===u||void 0===u.S&&u.className!==l.name&&u.Z===c-2?(n.Z=c-2,n.className=l.name,r[b]=n):(ab(r,b,p),r[b].S[c-2]=n);V([],m,function(t){t=ob(p,t,l,f,g);void 0===r[b].S?(t.Z=c-2,r[b]=t):r[b].S[c-2]=t;return[]});return[]})},A:function(a,b){b=N(b);W(a, +{name:b,fromWireType:function(c){var d=M(c);qb(c);return d},toWireType:function(c,d){return Ea(d)},argPackAdvance:8,readValueFromPointer:Xa,V:null})},n:function(a,b,c){c=Za(c);b=N(b);W(a,{name:b,fromWireType:function(d){return d},toWireType:function(d,e){return e},argPackAdvance:8,readValueFromPointer:rb(b,c),V:null})},e:function(a,b,c,d,e){b=N(b);-1===e&&(e=4294967295);e=Za(c);var f=k=>k;if(0===d){var g=32-8*c;f=k=>k<>>g}c=b.includes("unsigned")?function(k,m){return m>>>0}:function(k,m){return m}; +W(a,{name:b,fromWireType:f,toWireType:c,argPackAdvance:8,readValueFromPointer:sb(b,e,0!==d),V:null})},b:function(a,b,c){function d(f){f>>=2;var g=E;return new e(ia,g[f+1],g[f])}var e=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array][b];c=N(c);W(a,{name:c,fromWireType:d,argPackAdvance:8,readValueFromPointer:d},{ua:!0})},o:function(a,b){b=N(b);var c="std::string"===b;W(a,{name:b,fromWireType:function(d){var e=E[d>>2],f=d+4;if(c)for(var g=f,k=0;k<=e;++k){var m= +f+k;if(k==e||0==A[m]){g=g?z(A,g,m-g):"";if(void 0===l)var l=g;else l+=String.fromCharCode(0),l+=g;g=m+1}}else{l=Array(e);for(k=0;k=m?k++:2047>= +m?k+=2:55296<=m&&57343>=m?(k+=4,++f):k+=3}f=k}else f=e.length;k=Ib(4+f+1);m=k+4;E[k>>2]=f;if(c&&g){if(g=m,m=f+1,f=A,0=n){var p=e.charCodeAt(++l);n=65536+((n&1023)<<10)|p&1023}if(127>=n){if(g>=m)break;f[g++]=n}else{if(2047>=n){if(g+1>=m)break;f[g++]=192|n>>6}else{if(65535>=n){if(g+2>=m)break;f[g++]=224|n>>12}else{if(g+3>=m)break;f[g++]=240|n>>18;f[g++]=128|n>>12&63}f[g++]=128|n>>6&63}f[g++]=128|n&63}}f[g]=0}}else if(g)for(g= +0;gka;var k=1}else 4===b&&(d=wb,e=xb,f=yb,g=()=>E,k=2);W(a,{name:c,fromWireType:function(m){for(var l=E[m>>2],n=g(),p,r=m+4,u=0;u<=l;++u){var t=m+4+u*b;if(u==l||0==n[t>>k])r=d(r,t-r),void 0=== +p?p=r:(p+=String.fromCharCode(0),p+=r),r=t+b}S(m);return p},toWireType:function(m,l){"string"!=typeof l&&L("Cannot pass non-string to C++ string type "+c);var n=f(l),p=Ib(4+n+b);E[p>>2]=n>>k;e(l,p+4,n+b);null!==m&&m.push(S,p);return p},argPackAdvance:8,readValueFromPointer:Xa,V:function(m){S(m)}})},k:function(a,b,c,d,e,f){Va[a]={name:N(b),fa:Z(c,d),W:Z(e,f),ia:[]}},h:function(a,b,c,d,e,f,g,k,m,l){Va[a].ia.push({oa:N(b),ta:c,ra:Z(d,e),sa:f,za:g,ya:Z(k,m),Aa:l})},C:function(a,b){b=N(b);W(a,{va:!0,name:b, +argPackAdvance:0,fromWireType:function(){},toWireType:function(){}})},s:function(a,b,c,d,e){a=Bb[a];b=M(b);c=Ab(c);var f=[];E[d>>2]=Ea(f);return a(b,c,f,e)},t:function(a,b,c,d){a=Bb[a];b=M(b);c=Ab(c);a(b,c,null,d)},g:qb,m:function(a,b){var c=Db(a,b),d=c[0];b=d.name+"_$"+c.slice(1).map(function(g){return g.name}).join("_")+"$";var e=Eb[b];if(void 0!==e)return e;var f=Array(a-1);e=Cb((g,k,m,l)=>{for(var n=0,p=0;p>>=0;if(2147483648=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,a+100663296);var e=Math;d=Math.max(a,d);e=e.min.call(e,2147483648,d+(65536-d%65536)%65536);a:{try{fa.grow(e-ia.byteLength+65535>>>16);na();var f=1;break a}catch(g){}f= +void 0}if(f)return!0}return!1},z:function(){return 52},u:function(){return 70},y:function(a,b,c,d){for(var e=0,f=0;f>2],k=E[b+4>>2];b+=8;for(var m=0;m>2]=e;return 0}}; +(function(){function a(e){h.asm=e.exports;fa=h.asm.E;na();oa=h.asm.J;qa.unshift(h.asm.F);F--;h.monitorRunDependencies&&h.monitorRunDependencies(F);0==F&&(null!==ta&&(clearInterval(ta),ta=null),G&&(e=G,G=null,e()))}function b(e){a(e.instance)}function c(e){return ya().then(function(f){return WebAssembly.instantiate(f,d)}).then(function(f){return f}).then(e,function(f){v("failed to asynchronously prepare wasm: "+f);x(f)})}var d={a:Jb};F++;h.monitorRunDependencies&&h.monitorRunDependencies(F);if(h.instantiateWasm)try{return h.instantiateWasm(d, +a)}catch(e){v("Module.instantiateWasm callback failed with error: "+e),ca(e)}(function(){return w||"function"!=typeof WebAssembly.instantiateStreaming||ua(H)||"function"!=typeof fetch?c(b):fetch(H,{credentials:"same-origin"}).then(function(e){return WebAssembly.instantiateStreaming(e,d).then(b,function(f){v("wasm streaming compile failed: "+f);v("falling back to ArrayBuffer instantiation");return c(b)})})})().catch(ca);return{}})(); +h.___wasm_call_ctors=function(){return(h.___wasm_call_ctors=h.asm.F).apply(null,arguments)};var Ka=h.___getTypeName=function(){return(Ka=h.___getTypeName=h.asm.G).apply(null,arguments)};h.__embind_initialize_bindings=function(){return(h.__embind_initialize_bindings=h.asm.H).apply(null,arguments)};var Ib=h._malloc=function(){return(Ib=h._malloc=h.asm.I).apply(null,arguments)},S=h._free=function(){return(S=h._free=h.asm.K).apply(null,arguments)}; +h.dynCall_jiji=function(){return(h.dynCall_jiji=h.asm.L).apply(null,arguments)};var Kb;G=function Lb(){Kb||Mb();Kb||(G=Lb)}; +function Mb(){function a(){if(!Kb&&(Kb=!0,h.calledRun=!0,!ha)){za(qa);aa(h);if(h.onRuntimeInitialized)h.onRuntimeInitialized();if(h.postRun)for("function"==typeof h.postRun&&(h.postRun=[h.postRun]);h.postRun.length;){var b=h.postRun.shift();ra.unshift(b)}za(ra)}}if(!(0i64 in 85, bulk memory and the rest later. +// The scanner names every opcode, type and section form outside MVP. + +const MVP_VALTYPES = new Set([0x7f, 0x7e, 0x7d, 0x7c]); + +const OPCODE_FEATURES: Record = { + 0x06: 'exceptions', + 0x07: 'exceptions', + 0x08: 'exceptions', + 0x09: 'exceptions', + 0x0a: 'exceptions', + 0x12: 'tail-call', + 0x13: 'tail-call', + 0x14: 'function-references', + 0x15: 'function-references', + 0x18: 'exceptions', + 0x19: 'exceptions', + 0x1c: 'reference-types', + 0x1f: 'exceptions', + 0x25: 'reference-types', + 0x26: 'reference-types', + 0xc0: 'sign-ext', + 0xc1: 'sign-ext', + 0xc2: 'sign-ext', + 0xc3: 'sign-ext', + 0xc4: 'sign-ext', + 0xd0: 'reference-types', + 0xd1: 'reference-types', + 0xd2: 'reference-types', + 0xfb: 'gc', + 0xfd: 'simd', + 0xfe: 'threads', +}; + +function scanWasmFeatures(bytes: Uint8Array): Record { + const features: Record = {}; + const hit = (feature: string) => { + features[feature] = (features[feature] ?? 0) + 1; + }; + let p = 8; + const byte = () => bytes[p++] ?? 0; + const uleb = () => { + let result = 0; + let shift = 0; + let b: number; + + do { + b = byte(); + result += (b & 0x7f) * 2 ** shift; + shift += 7; + } while (b & 0x80); + + return result; + }; + const skipLeb = () => { + while (byte() & 0x80); + }; + const skip = (length: number) => { + p += length; + }; + const valtype = () => { + const t = byte(); + + if (!MVP_VALTYPES.has(t)) { + hit(t === 0x7b ? 'simd' : 'reference-types'); + } + + return t; + }; + const limits = () => { + const flags = byte(); + + if (flags & 0x02) hit('threads (shared memory)'); + if (flags & 0x04) hit('memory64'); + if (flags > 0x07) hit('unknown limits flag'); + + uleb(); + if (flags & 0x01) uleb(); + }; + const constExpr = () => { + const op = byte(); + + if (op === 0x41 || op === 0x42 || op === 0x23) skipLeb(); + else if (op === 0x43) p += 4; + else if (op === 0x44) p += 8; + else hit('non-MVP constant expression'); + + if (byte() !== 0x0b) hit('extended-const'); + }; + + const types: { params: number[]; results: number[] }[] = []; + const usesI64 = (type?: { params: number[]; results: number[] }) => + !!type && [...type.params, ...type.results].includes(0x7e); + const funcTypes: number[] = []; + const globalMutable: boolean[] = []; + let tables = 0; + let memories = 0; + + expect([...bytes.subarray(0, 8)]).toEqual([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]); + + while (p < bytes.length) { + const id = byte(); + const size = uleb(); + const end = p + size; + + switch (id) { + case 0: + break; + case 1: { + const count = uleb(); + + for (let i = 0; i < count; i++) { + if (byte() !== 0x60) hit('gc (non-func type)'); + + const params = Array.from({ length: uleb() }, valtype); + const results = Array.from({ length: uleb() }, valtype); + + if (results.length > 1) hit('multi-value'); + + types.push({ params, results }); + } + break; + } + case 2: { + const count = uleb(); + + for (let i = 0; i < count; i++) { + skip(uleb()); + skip(uleb()); + const kind = byte(); + + if (kind === 0) { + const typeIndex = uleb(); + + if (usesI64(types[typeIndex])) hit('bigint-integration (i64 in imported signature)'); + + funcTypes.push(typeIndex); + } else if (kind === 1) { + if (byte() !== 0x70) hit('reference-types (externref table)'); + limits(); + tables++; + } else if (kind === 2) { + limits(); + memories++; + } else if (kind === 3) { + valtype(); + const mutable = byte() === 1; + + if (mutable) hit('mutable-globals (import)'); + + globalMutable.push(mutable); + } else { + hit('exceptions (tag import)'); + } + } + break; + } + case 3: { + const count = uleb(); + + for (let i = 0; i < count; i++) funcTypes.push(uleb()); + break; + } + case 4: { + const count = uleb(); + + for (let i = 0; i < count; i++) { + if (byte() !== 0x70) hit('reference-types (externref table)'); + limits(); + tables++; + } + break; + } + case 5: { + const count = uleb(); + + for (let i = 0; i < count; i++) { + limits(); + memories++; + } + break; + } + case 6: { + const count = uleb(); + + for (let i = 0; i < count; i++) { + valtype(); + globalMutable.push(byte() === 1); + constExpr(); + } + break; + } + case 7: { + const count = uleb(); + + for (let i = 0; i < count; i++) { + skip(uleb()); + const kind = byte(); + const index = uleb(); + + if (kind === 0) { + if (usesI64(types[funcTypes[index] ?? -1])) { + hit('bigint-integration (i64 in exported signature)'); + } + } else if (kind === 3 && globalMutable[index]) { + hit('mutable-globals (export)'); + } else if (kind > 3) { + hit('exceptions (tag export)'); + } + } + break; + } + case 8: + uleb(); + break; + case 9: { + const count = uleb(); + + for (let i = 0; i < count; i++) { + if (uleb() !== 0) { + hit('bulk-memory / reference-types (element segment form)'); + break; + } + + constExpr(); + const n = uleb(); + + for (let j = 0; j < n; j++) uleb(); + } + break; + } + case 10: { + const count = uleb(); + + for (let f = 0; f < count; f++) { + const bodySize = uleb(); + const bodyEnd = p + bodySize; + const localGroups = uleb(); + + for (let i = 0; i < localGroups; i++) { + uleb(); + valtype(); + } + + body: while (p < bodyEnd) { + const op = byte(); + const feature = OPCODE_FEATURES[op]; + + if (feature) { + hit(feature); + // Immediates of non-MVP opcodes aren't decoded, so stop here. + break body; + } + + if (op === 0x02 || op === 0x03 || op === 0x04) { + const blockType = byte(); + + if (blockType !== 0x40 && !MVP_VALTYPES.has(blockType)) { + hit(blockType === 0x7b ? 'simd' : 'multi-value (typed block)'); + break body; + } + } else if (op === 0x0c || op === 0x0d || op === 0x10 || (op >= 0x20 && op <= 0x24)) { + uleb(); + } else if (op === 0x0e) { + const n = uleb(); + + for (let i = 0; i <= n; i++) uleb(); + } else if (op === 0x11) { + uleb(); + if (byte() !== 0) hit('reference-types (call_indirect on table > 0)'); + } else if (op >= 0x28 && op <= 0x3e) { + uleb(); + uleb(); + } else if (op === 0x3f || op === 0x40) { + if (byte() !== 0) hit('multi-memory'); + } else if (op === 0x41 || op === 0x42) { + skipLeb(); + } else if (op === 0x43) { + p += 4; + } else if (op === 0x44) { + p += 8; + } else if (op === 0xfc) { + hit(uleb() <= 7 ? 'nontrapping-fptoint' : 'bulk-memory'); + break body; + } else if ( + !(op <= 0x01 || op === 0x05 || op === 0x0b || op === 0x0f || op === 0x1a) && + !(op === 0x1b || (op >= 0x45 && op <= 0xbf)) + ) { + hit(`unknown opcode 0x${op.toString(16)}`); + break body; + } + } + + p = bodyEnd; + } + break; + } + case 11: { + const count = uleb(); + + for (let i = 0; i < count; i++) { + if (uleb() !== 0) { + hit('bulk-memory (passive or indexed data segment)'); + break; + } + + constExpr(); + skip(uleb()); + } + break; + } + case 12: + hit('bulk-memory (datacount section)'); + break; + case 13: + hit('exceptions (tag section)'); + break; + default: + hit(`unknown section ${id}`); + } + + p = end; + } + + if (tables > 1) hit('reference-types (multiple tables)'); + if (memories > 1) hit('multi-memory'); + + return features; +} + +const WASM_DATA_URI = /data:application\/octet-stream;base64,([A-Za-z0-9+/=]+)/; + +const here = path.dirname(fileURLToPath(import.meta.url)); +const vendorDir = path.join(here, 'vendor'); +const yogaDist = path.resolve(createRequire(import.meta.url).resolve('yoga-layout/load'), '../..'); + +const read = (file: string) => readFileSync(file, 'utf8'); +const embeddedWasm = (source: string) => + new Uint8Array(Buffer.from(source.match(WASM_DATA_URI)?.[1] ?? '', 'base64')); +const stripSourceMap = (source: string) => source.replace(/\n\/\/# sourceMappingURL=.*$/m, '\n'); + +const vendoredGlue = read(path.join(vendorDir, 'yoga-wasm-mvp.js')); +const upstreamGlue = stripSourceMap(read(path.join(yogaDist, 'binaries/yoga-wasm-base64-esm.js'))); + +describe('vendored yoga wasm', () => { + it('uses nothing beyond WebAssembly MVP (Chrome 57)', () => { + expect(scanWasmFeatures(embeddedWasm(vendoredGlue))).toEqual({}); + }); + + it('catches the sign-ext opcodes in the upstream build', () => { + expect(scanWasmFeatures(embeddedWasm(upstreamGlue))).toEqual({ 'sign-ext': 2 }); + }); + + it('catches post-MVP features outside function bodies', () => { + const header = [0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]; + // A mutable i32 global, exported. + const mutableGlobalExport = new Uint8Array( + header.concat([ + 0x06, 0x06, 0x01, 0x7f, 0x01, 0x41, 0x00, 0x0b, 0x07, 0x05, 0x01, 0x01, 0x67, 0x03, 0x00, + ]), + ); + // An exported (i64) => void function. + const i64Export = new Uint8Array( + header.concat( + [0x01, 0x05, 0x01, 0x60, 0x01, 0x7e, 0x00, 0x03, 0x02, 0x01, 0x00], + [0x07, 0x05, 0x01, 0x01, 0x66, 0x00, 0x00, 0x0a, 0x04, 0x01, 0x02, 0x00, 0x0b], + ), + ); + + expect(WebAssembly.validate(mutableGlobalExport)).toBe(true); + expect(WebAssembly.validate(i64Export)).toBe(true); + expect(scanWasmFeatures(mutableGlobalExport)).toEqual({ 'mutable-globals (export)': 1 }); + expect(scanWasmFeatures(i64Export)).toEqual({ + 'bigint-integration (i64 in exported signature)': 1, + }); + }); + + it('matches the installed yoga-layout (rerun `pnpm vendor:yoga` after a bump)', () => { + const sha = createHash('sha256').update(embeddedWasm(upstreamGlue)).digest('hex'); + const withoutWasm = (source: string) => source.replace(WASM_DATA_URI, ''); + + expect(vendoredGlue).toContain(`// source-wasm-sha256: ${sha}\n`); + expect( + withoutWasm(vendoredGlue).endsWith( + withoutWasm(upstreamGlue).replace( + 'var _scriptDir = import.meta.url;', + 'var _scriptDir = "";', + ), + ), + ).toBe(true); + expect(read(path.join(vendorDir, 'wrapAssembly.js'))).toBe( + stripSourceMap(read(path.join(yogaDist, 'src/wrapAssembly.js'))).replaceAll( + './generated/YGEnums.js', + './YGEnums.js', + ), + ); + expect(read(path.join(vendorDir, 'YGEnums.js'))).toBe( + stripSourceMap(read(path.join(yogaDist, 'src/generated/YGEnums.js'))), + ); + }); + + it('lays out a tree', async () => { + const yoga = await loadYoga(); + const root = yoga.Node.create(); + const child = yoga.Node.create(); + + root.setFlexDirection(yoga.FLEX_DIRECTION_ROW); + root.setWidth(300); + root.setHeight(100); + root.setPadding(yoga.EDGE_ALL, 10); + child.setFlexGrow(1); + child.setMargin(yoga.EDGE_LEFT, 5); + root.insertChild(child, 0); + root.calculateLayout(undefined, undefined, yoga.DIRECTION_LTR); + + expect(child.getComputedLayout()).toMatchObject({ + left: 15, + top: 10, + width: 275, + height: 80, + }); + + root.freeRecursive(); + }); +}); diff --git a/packages/plugin-flexbox/vite.config.ts b/packages/plugin-flexbox/vite.config.ts index 5d0415b0..d434511e 100644 --- a/packages/plugin-flexbox/vite.config.ts +++ b/packages/plugin-flexbox/vite.config.ts @@ -20,5 +20,11 @@ export default defineConfig((env) => build: { target: buildTarget, }, + // The inline worker is a separate bundle that doesn't inherit build.target. + worker: { + rolldownOptions: { + transform: { target: buildTarget }, + }, + }, }), ); From e293fcdfd5dad3eb869f8fd182f1fc31c1da58de Mon Sep 17 00:00:00 2001 From: Ruud Date: Thu, 15 Oct 2026 14:32:35 +0200 Subject: [PATCH 2/4] keep render working on chrome 57-73 without resizeobserver --- .changeset/legacy-chrome-apis.md | 6 ++ .../src/element/LightningViewElement.ts | 3 +- .../react-lightning/src/focus/FocusManager.ts | 8 +-- .../src/focus/activeFocusManager.ts | 2 +- .../src/hooks/useDebugHooks.ts | 2 +- .../src/input/KeyPressHandler.tsx | 3 +- .../src/render/createHostConfig.ts | 3 +- .../shim/resizeObserverShim.legacy.spec.ts | 68 +++++++++++++++++++ .../src/shim/resizeObserverShim.ts | 41 +++++++++-- .../src/utils/scheduleMicrotask.spec.ts | 30 ++++++++ .../src/utils/scheduleMicrotask.ts | 7 ++ .../src/exports/StyleSheet.ts | 18 ++++- 12 files changed, 174 insertions(+), 17 deletions(-) create mode 100644 .changeset/legacy-chrome-apis.md create mode 100644 packages/react-lightning/src/shim/resizeObserverShim.legacy.spec.ts create mode 100644 packages/react-lightning/src/utils/scheduleMicrotask.spec.ts create mode 100644 packages/react-lightning/src/utils/scheduleMicrotask.ts diff --git a/.changeset/legacy-chrome-apis.md b/.changeset/legacy-chrome-apis.md new file mode 100644 index 00000000..7ef3d3f7 --- /dev/null +++ b/.changeset/legacy-chrome-apis.md @@ -0,0 +1,6 @@ +--- +'@plextv/react-lightning': patch +'@plextv/react-native-lightning': patch +--- + +Run on Chrome 57-73 (webOS 5, Tizen 5.x): the ResizeObserver shim no longer crashes `render()` when the browser has no ResizeObserver or DOMRectReadOnly, microtasks fall back to a promise where `queueMicrotask` is missing, and `Array.prototype.at` / `flat` are no longer used on the render, focus and key paths. diff --git a/packages/react-lightning/src/element/LightningViewElement.ts b/packages/react-lightning/src/element/LightningViewElement.ts index 0fa1b546..5f3dd0d9 100644 --- a/packages/react-lightning/src/element/LightningViewElement.ts +++ b/packages/react-lightning/src/element/LightningViewElement.ts @@ -30,6 +30,7 @@ import { type ShaderDef, type TextureDef, } from '../types'; +import { scheduleMicrotask } from '../utils/scheduleMicrotask'; import { AllStyleProps } from './AllStyleProps'; import { createFlattenedNode } from './FlattenedRendererNode'; import { isTranslateSettled, MAX_UNSETTLED_LAYOUTS } from './isTranslateSettled'; @@ -1370,7 +1371,7 @@ export class LightningViewElement< this._isUpdateQueued = true; - queueMicrotask(() => { + scheduleMicrotask(() => { const changed = this._doUpdate(); if (changed) { diff --git a/packages/react-lightning/src/focus/FocusManager.ts b/packages/react-lightning/src/focus/FocusManager.ts index 1258e692..46b31192 100644 --- a/packages/react-lightning/src/focus/FocusManager.ts +++ b/packages/react-lightning/src/focus/FocusManager.ts @@ -2,6 +2,7 @@ import { EventEmitter, type IEventEmitter } from 'tseep'; import type { Focusable } from '../types'; import type { EventNotifier } from '../types/EventNotifier'; +import { scheduleMicrotask } from '../utils/scheduleMicrotask'; import type { Traps } from './Traps'; type RootNode = { @@ -280,9 +281,8 @@ export class FocusManager< // their hooks are run before getting attached to the tree. This causes // the component to get added to the old layer before the new layer's // created. - const parentNodeInPreviousLayer: RootNode | FocusNode | undefined = this._focusStack - .at(-2) - ?.elements?.get?.(parent); + const parentNodeInPreviousLayer: RootNode | FocusNode | undefined = + this._focusStack[this._focusStack.length - 2]?.elements?.get?.(parent); if (parentNodeInPreviousLayer && !isRootNode(parentNodeInPreviousLayer)) { parentNode = this._addMissingParentsToCurrentLayer(parentNodeInPreviousLayer); @@ -2122,7 +2122,7 @@ export class FocusManager< } this._initialFocusPending = true; - queueMicrotask(() => { + scheduleMicrotask(() => { this._initialFocusPending = false; this._settleRepicks(); this._recalculateFocusPath(); diff --git a/packages/react-lightning/src/focus/activeFocusManager.ts b/packages/react-lightning/src/focus/activeFocusManager.ts index 77c73c61..5c0b6b56 100644 --- a/packages/react-lightning/src/focus/activeFocusManager.ts +++ b/packages/react-lightning/src/focus/activeFocusManager.ts @@ -24,7 +24,7 @@ export function registerFocusManager(focusManager: Manager): () => void { } export function getFocusManager(): Manager | null { - return registered.at(-1) ?? null; + return registered[registered.length - 1] ?? null; } export function containsFocus(key: string): boolean { diff --git a/packages/react-lightning/src/hooks/useDebugHooks.ts b/packages/react-lightning/src/hooks/useDebugHooks.ts index b73722d2..93f33f2b 100644 --- a/packages/react-lightning/src/hooks/useDebugHooks.ts +++ b/packages/react-lightning/src/hooks/useDebugHooks.ts @@ -5,7 +5,7 @@ type DebuggableHook = (...args: any[]) => any; function wrapHook(hook: T, name: string): T { return ((...args) => { - const dependencies = args.at(-1) as DependencyList; + const dependencies = args[args.length - 1] as DependencyList; const prevValue = useRef([]); const changedDeps = dependencies.reduce>( diff --git a/packages/react-lightning/src/input/KeyPressHandler.tsx b/packages/react-lightning/src/input/KeyPressHandler.tsx index 5d99c5f8..1ac66e8f 100644 --- a/packages/react-lightning/src/input/KeyPressHandler.tsx +++ b/packages/react-lightning/src/input/KeyPressHandler.tsx @@ -18,7 +18,8 @@ export const KeyPressHandler: FC<{ children: ReactNode }> = ({ children }) => { const createKeyHandler = (handler: 'onKeyDown' | 'onKeyUp') => { return (event: KeyboardEvent) => { - const element = focusManager.focusPath.at(-1); + const { focusPath } = focusManager; + const element = focusPath[focusPath.length - 1]; if (!element || !(event instanceof KeyboardEvent)) { return; diff --git a/packages/react-lightning/src/render/createHostConfig.ts b/packages/react-lightning/src/render/createHostConfig.ts index a9e4534c..101cf109 100644 --- a/packages/react-lightning/src/render/createHostConfig.ts +++ b/packages/react-lightning/src/render/createHostConfig.ts @@ -11,6 +11,7 @@ import { LightningElementType, type RendererNode, } from '../types'; +import { scheduleMicrotask } from '../utils/scheduleMicrotask'; import { simpleDiff } from '../utils/simpleDiff'; import { isPrimitiveTextContent } from './isValidTextChild'; import { mapReactPropsToLightning } from './mapReactPropsToLightning'; @@ -75,7 +76,7 @@ export function createHostConfig(options?: LightningHostConfigOptions): Lightnin supportsPersistence: false, supportsHydration: false, supportsMicrotasks: true, - scheduleMicrotask: queueMicrotask, + scheduleMicrotask, scheduleTimeout: setTimeout, cancelTimeout: clearTimeout, noTimeout: -1, diff --git a/packages/react-lightning/src/shim/resizeObserverShim.legacy.spec.ts b/packages/react-lightning/src/shim/resizeObserverShim.legacy.spec.ts new file mode 100644 index 00000000..dd1b2ebe --- /dev/null +++ b/packages/react-lightning/src/shim/resizeObserverShim.legacy.spec.ts @@ -0,0 +1,68 @@ +import { beforeAll, describe, expect, it, vi } from 'vitest'; + +import type { Rect } from '../types'; + +vi.mock('../element/LightningViewElement', () => { + class LightningViewElement { + private _handlers = new Set<(rect: Rect) => void>(); + + public on(_event: string, handler: (rect: Rect) => void): void { + this._handlers.add(handler); + } + + public off(_event: string, handler: (rect: Rect) => void): void { + this._handlers.delete(handler); + } + + public emit(rect: Rect): void { + this._handlers.forEach((handler) => handler(rect)); + } + } + + return { LightningViewElement }; +}); + +type LayoutTarget = { emit(rect: Rect): void }; + +let LightningViewElementMock: new () => LayoutTarget; + +beforeAll(async () => { + vi.stubGlobal('window', {}); + vi.stubGlobal('ResizeObserver', undefined); + vi.stubGlobal('DOMRectReadOnly', undefined); + + ({ LightningViewElement: LightningViewElementMock } = + (await import('../element/LightningViewElement')) as unknown as { + LightningViewElement: new () => LayoutTarget; + }); +}); + +describe('LightningResizeObserver without a native ResizeObserver', () => { + it('imports without throwing and installs itself', async () => { + await expect(import('./resizeObserverShim')).resolves.toBeDefined(); + expect(typeof window.ResizeObserver).toBe('function'); + }); + + it('still reports Lightning targets and ignores DOM targets', () => { + const callback = vi.fn(); + const observer = new window.ResizeObserver(callback); + const target = new LightningViewElementMock(); + + observer.observe(target as unknown as Element); + expect(() => observer.observe({} as Element)).not.toThrow(); + + target.emit({ x: 1, y: 2, w: 3, h: 4 }); + + expect(callback).toHaveBeenCalledTimes(1); + expect(callback.mock.calls[0]?.[0][0]?.contentRect).toMatchObject({ + x: 1, + y: 2, + width: 3, + height: 4, + right: 4, + bottom: 6, + }); + + expect(() => observer.disconnect()).not.toThrow(); + }); +}); diff --git a/packages/react-lightning/src/shim/resizeObserverShim.ts b/packages/react-lightning/src/shim/resizeObserverShim.ts index 28bc2876..f4aa4c17 100644 --- a/packages/react-lightning/src/shim/resizeObserverShim.ts +++ b/packages/react-lightning/src/shim/resizeObserverShim.ts @@ -1,7 +1,39 @@ import { LightningViewElement } from '../element/LightningViewElement'; import type { Rect } from '../types'; -class LightningResizeObserver extends window.ResizeObserver { +// Chrome < 64 (Tizen 5.0) has no ResizeObserver: Lightning targets still +// report, DOM targets are ignored. +class NoopResizeObserver { + public constructor(_callback: ResizeObserverCallback) {} + public observe(_target: Element, _options?: ResizeObserverOptions): void {} + public unobserve(_target: Element): void {} + public disconnect(): void {} +} + +const BaseResizeObserver: typeof ResizeObserver = + (window.ResizeObserver as typeof ResizeObserver | undefined) ?? NoopResizeObserver; + +function toRect(dimensions: Rect): DOMRectReadOnly { + if (typeof DOMRectReadOnly !== 'undefined') { + return new DOMRectReadOnly(dimensions.x, dimensions.y, dimensions.w, dimensions.h); + } + + const { x, y, w, h } = dimensions; + + return { + x, + y, + width: w, + height: h, + top: y, + left: x, + right: x + w, + bottom: y + h, + toJSON: () => ({ x, y, width: w, height: h }), + }; +} + +class LightningResizeObserver extends BaseResizeObserver { private _callback: ResizeObserverCallback; // Per-target layout handler so each entry reports its own target's rect and // the handler ref stays removable on unobserve/disconnect. @@ -80,12 +112,7 @@ class LightningResizeObserver extends window.ResizeObserver { inlineSize: dimensions.w, }, ], - contentRect: new DOMRectReadOnly( - dimensions.x, - dimensions.y, - dimensions.w, - dimensions.h, - ), + contentRect: toRect(dimensions), target: target as unknown as Element, }; diff --git a/packages/react-lightning/src/utils/scheduleMicrotask.spec.ts b/packages/react-lightning/src/utils/scheduleMicrotask.spec.ts new file mode 100644 index 00000000..ff08a688 --- /dev/null +++ b/packages/react-lightning/src/utils/scheduleMicrotask.spec.ts @@ -0,0 +1,30 @@ +import { afterEach, describe, expect, it, vi } from 'vitest'; + +afterEach(() => { + vi.unstubAllGlobals(); + vi.resetModules(); +}); + +describe('scheduleMicrotask', () => { + it('falls back to a promise when queueMicrotask is missing', async () => { + vi.stubGlobal('queueMicrotask', undefined); + const { scheduleMicrotask } = await import('./scheduleMicrotask'); + const callback = vi.fn(); + + scheduleMicrotask(callback); + expect(callback).not.toHaveBeenCalled(); + + await Promise.resolve(); + expect(callback).toHaveBeenCalledTimes(1); + }); + + it('uses queueMicrotask when it exists', async () => { + const native = vi.fn(); + vi.stubGlobal('queueMicrotask', native); + const { scheduleMicrotask } = await import('./scheduleMicrotask'); + const callback = vi.fn(); + + scheduleMicrotask(callback); + expect(native).toHaveBeenCalledWith(callback); + }); +}); diff --git a/packages/react-lightning/src/utils/scheduleMicrotask.ts b/packages/react-lightning/src/utils/scheduleMicrotask.ts new file mode 100644 index 00000000..de3c50e8 --- /dev/null +++ b/packages/react-lightning/src/utils/scheduleMicrotask.ts @@ -0,0 +1,7 @@ +// queueMicrotask needs Chrome 71; webOS 5 and Tizen 5.x ship older Chromes. +export const scheduleMicrotask: (callback: () => void) => void = + typeof queueMicrotask === 'function' + ? (callback) => queueMicrotask(callback) + : (callback) => { + void Promise.resolve().then(callback); + }; diff --git a/packages/react-native-lightning/src/exports/StyleSheet.ts b/packages/react-native-lightning/src/exports/StyleSheet.ts index e3e8b0a0..03336073 100644 --- a/packages/react-native-lightning/src/exports/StyleSheet.ts +++ b/packages/react-native-lightning/src/exports/StyleSheet.ts @@ -4,10 +4,26 @@ export function create( return stylesObject; } +// Array.prototype.flat needs Chrome 69. +function flattenDeep(values: readonly unknown[], out: unknown[]): unknown[] { + for (const value of values) { + if (Array.isArray(value)) { + flattenDeep(value, out); + } else { + out.push(value); + } + } + + return out; +} + export function flatten(...args: T[]): Exclude { return Object.assign( {}, - ...args.filter((obj) => obj != null && obj !== false).flat(Number.POSITIVE_INFINITY), + ...flattenDeep( + args.filter((obj) => obj != null && obj !== false), + [], + ), ); } From 49798f0175c33f4e99c64299097fc2010bae8630 Mon Sep 17 00:00:00 2001 From: Ruud Date: Thu, 15 Oct 2026 15:01:55 +0200 Subject: [PATCH 3/4] drop chrome 71+ apis from plugin-reanimated --- .changeset/reanimated-legacy-chrome.md | 6 ++++++ packages/plugin-reanimated/src/css/focusWithin.ts | 8 ++++++-- .../plugin-reanimated/src/exports/useAnimatedStyle.ts | 4 ++-- .../plugin-reanimated/src/exports/useTrackedReaction.ts | 4 +++- packages/react-lightning/src/index.ts | 1 + 5 files changed, 18 insertions(+), 5 deletions(-) create mode 100644 .changeset/reanimated-legacy-chrome.md diff --git a/.changeset/reanimated-legacy-chrome.md b/.changeset/reanimated-legacy-chrome.md new file mode 100644 index 00000000..3a957687 --- /dev/null +++ b/.changeset/reanimated-legacy-chrome.md @@ -0,0 +1,6 @@ +--- +'@plextv/react-lightning': patch +'@plextv/react-lightning-plugin-reanimated': patch +--- + +Animated styles and `:focus-within` no longer need Chrome 71+ / 92+: they schedule through the exported `scheduleMicrotask` (a promise where `queueMicrotask` is missing) and read the focus leaf by index instead of `Array.prototype.at`. diff --git a/packages/plugin-reanimated/src/css/focusWithin.ts b/packages/plugin-reanimated/src/css/focusWithin.ts index 05083ec4..a3ea1442 100644 --- a/packages/plugin-reanimated/src/css/focusWithin.ts +++ b/packages/plugin-reanimated/src/css/focusWithin.ts @@ -43,7 +43,9 @@ class FocusWithinTracker { } private _contains(element: LightningElement, path: LightningElement[]): boolean { - for (let node: LightningElement | null | undefined = path.at(-1); node; node = node.parent) { + const leaf: LightningElement | undefined = path[path.length - 1]; + + for (let node: LightningElement | null | undefined = leaf; node; node = node.parent) { if (node === element) { return true; } @@ -55,7 +57,9 @@ class FocusWithinTracker { private _onFocusPathChanged = (path: LightningElement[]): void => { const next = new Set(); - for (let node: LightningElement | null | undefined = path.at(-1); node; node = node.parent) { + const leaf: LightningElement | undefined = path[path.length - 1]; + + for (let node: LightningElement | null | undefined = leaf; node; node = node.parent) { if (this._listeners.has(node)) { next.add(node); } diff --git a/packages/plugin-reanimated/src/exports/useAnimatedStyle.ts b/packages/plugin-reanimated/src/exports/useAnimatedStyle.ts index 74d195a6..b5c0762d 100644 --- a/packages/plugin-reanimated/src/exports/useAnimatedStyle.ts +++ b/packages/plugin-reanimated/src/exports/useAnimatedStyle.ts @@ -4,7 +4,7 @@ import type { useAnimatedStyle as useAnimatedStyleRN } from 'react-native-reanim import type { Mutable } from 'react-native-reanimated/lib/typescript/commonTypes'; import type { DefaultStyle } from 'react-native-reanimated/lib/typescript/hook/commonTypes'; -import { PARTIAL_STYLE } from '@plextv/react-lightning'; +import { PARTIAL_STYLE, scheduleMicrotask } from '@plextv/react-lightning'; import type { LightningElement, LightningElementStyle } from '@plextv/react-lightning'; import { type RunningProgram, reconcileRunners } from '../animation/reconcileRunners'; @@ -102,7 +102,7 @@ export const useAnimatedStyle: UseAnimatedStyleFn = (updater, dependencies) => { pendingRef.current = true; - queueMicrotask(() => { + scheduleMicrotask(() => { pendingRef.current = false; applyComputedStyle(updater(), views, lastApplied, runners); }); diff --git a/packages/plugin-reanimated/src/exports/useTrackedReaction.ts b/packages/plugin-reanimated/src/exports/useTrackedReaction.ts index f302fef8..909fdb1b 100644 --- a/packages/plugin-reanimated/src/exports/useTrackedReaction.ts +++ b/packages/plugin-reanimated/src/exports/useTrackedReaction.ts @@ -2,6 +2,8 @@ import type { DependencyList } from 'react'; import { useEffect, useRef, useState } from 'react'; import type { Mutable } from 'react-native-reanimated/lib/typescript/commonTypes'; +import { scheduleMicrotask } from '@plextv/react-lightning'; + import { collectSharedValueReads, nextTrackingListenerId } from '../utils/sharedValueTracking'; type TrackedState = { @@ -33,7 +35,7 @@ export function useTrackedReaction( pendingRef.current = true; - queueMicrotask(() => { + scheduleMicrotask(() => { pendingRef.current = false; const { compute: currentCompute, apply: currentApply } = stateRef.current; diff --git a/packages/react-lightning/src/index.ts b/packages/react-lightning/src/index.ts index bec6edba..3a1a5e5c 100644 --- a/packages/react-lightning/src/index.ts +++ b/packages/react-lightning/src/index.ts @@ -38,5 +38,6 @@ export { export { createRoot, type LightningRoot, LightningRootContext, type RenderOptions } from './render'; export type { Plugin } from './render/Plugin'; export * from './types'; +export { scheduleMicrotask } from './utils/scheduleMicrotask'; export { simpleDiff } from './utils/simpleDiff'; export { CanvasRoot } from './components/Canvas/CanvasRoot'; From 12d4b1d1c5514fe5691e4ac881afcd6dd53c1a1c Mon Sep 17 00:00:00 2001 From: Ruud Date: Thu, 15 Oct 2026 15:01:55 +0200 Subject: [PATCH 4/4] read the pointer scroll hook without globalthis --- .changeset/virtuallist-no-globalthis.md | 5 +++++ .../VirtualList/useScrollHandler.ts | 20 ++++++++++++++----- 2 files changed, 20 insertions(+), 5 deletions(-) create mode 100644 .changeset/virtuallist-no-globalthis.md diff --git a/.changeset/virtuallist-no-globalthis.md b/.changeset/virtuallist-no-globalthis.md new file mode 100644 index 00000000..7b475eb4 --- /dev/null +++ b/.changeset/virtuallist-no-globalthis.md @@ -0,0 +1,5 @@ +--- +'@plextv/react-lightning-components': patch +--- + +VirtualList reads the pointer focus-scroll hook off `window` (or `self`) instead of `globalThis`, which needs Chrome 71. diff --git a/packages/react-lightning-components/src/components/VirtualList/useScrollHandler.ts b/packages/react-lightning-components/src/components/VirtualList/useScrollHandler.ts index 4839b84e..dcdd751b 100644 --- a/packages/react-lightning-components/src/components/VirtualList/useScrollHandler.ts +++ b/packages/react-lightning-components/src/components/VirtualList/useScrollHandler.ts @@ -13,12 +13,22 @@ import { resolveScrollToIndexTarget } from './resolveScrollToIndexTarget'; import { createCriticalSpring } from './scrollSpring'; import type { ScrollEvent } from './VirtualListTypes'; -// Lightning Magic Remote / mouse support (in the host app) installs this hook -// while a pointer is driving focus. Read it off globalThis so this subtree stays -// free of app imports; undefined (a no-op) on every platform that never loads it. +type PointerFocusScrollHost = { __plexShouldSuppressPointerFocusScroll?: () => boolean }; + +// The host app's pointer support installs this hook on the global, keeping app imports +// out of here. Not globalThis: it needs Chrome 71, and webOS 5 / Tizen 5.x are older. +const hostGlobal = ( + typeof window !== 'undefined' + ? window + : typeof self !== 'undefined' + ? self + : typeof global !== 'undefined' + ? global + : undefined +) as PointerFocusScrollHost | undefined; + const isPointerFocusScrollSuppressed = (): boolean => { - const fn = (globalThis as { __plexShouldSuppressPointerFocusScroll?: () => boolean }) - .__plexShouldSuppressPointerFocusScroll; + const fn = hostGlobal?.__plexShouldSuppressPointerFocusScroll; return typeof fn === 'function' && fn(); };