@pibbl/core 0.0.1

package/dist/lib/execute-render.js

@@ -0,0 +1,195 @@
+import { RootRenderTransaction } from "./render-transaction.js";
+import {
+  clearTempState,
+  GLOBAL_STATE,
+  NO_PENDING_ROOT
+} from "./global-state.js";
+import { render } from "./render.js";
+import { initializeCurrentWorldTransformAnchor } from "./render-target.js";
+import { withSignalWriteForbidden } from "./signals/graph.js";
+function executeRender(canvas, renderTimestamp, updatedRoot, _updateParents = false, frameSnapshot) {
+  if (!canvas) {
+    throw new Error("No canvas element provided");
+  }
+  const pibblInstance = GLOBAL_STATE.pibblInstances.get(canvas);
+  if (!pibblInstance) {
+    throw new Error("Pibbl is not mounted on this element");
+  }
+  if (pibblInstance.mainTeardowns.closed) return;
+  const inheritedTransaction = pibblInstance.eventRoot.renderTransaction;
+  const renderTransaction = inheritedTransaction ?? new RootRenderTransaction();
+  const ownsRenderTransaction = !inheritedTransaction;
+  if (ownsRenderTransaction) {
+    pibblInstance.eventRoot.renderTransaction = renderTransaction;
+  }
+  let transactionFinished = false;
+  const finishTransaction = (success) => {
+    if (!ownsRenderTransaction || transactionFinished) return;
+    transactionFinished = true;
+    renderTransaction.finish(success);
+  };
+  const prevCurrentPibblInstance = GLOBAL_STATE.currentPibblInstance;
+  const prevCanvas = GLOBAL_STATE.canvas;
+  const prevRenderContext = GLOBAL_STATE.renderContext;
+  const prevRenderTarget = GLOBAL_STATE.renderTarget;
+  const prevWorldBaseTransform = GLOBAL_STATE.worldBaseTransform;
+  const prevWorldExactTransform = GLOBAL_STATE.worldExactTransform;
+  const prevWorldPaintAnchorTransform = GLOBAL_STATE.worldPaintAnchorTransform;
+  const prevPresentationTransformLineage = GLOBAL_STATE.presentationTransformLineage;
+  const prevPresentationTransformLineageTrackingDepth = GLOBAL_STATE.presentationTransformLineageTrackingDepth;
+  const prevRenderTransaction = GLOBAL_STATE.renderTransaction;
+  const prevFrameSnapshot = GLOBAL_STATE.frameSnapshot;
+  const prevPrimitiveReceiverToken = GLOBAL_STATE.primitiveReceiverToken;
+  const prevSeenIds = GLOBAL_STATE.seenIds;
+  const prevSeenKeys = GLOBAL_STATE.seenKeys;
+  const prevComponentRefs = GLOBAL_STATE.componentRefs;
+  const prevComponentHookIndex = GLOBAL_STATE.componentHookIndex;
+  const prevComponentIsMounting = GLOBAL_STATE.componentIsMounting;
+  const prevClippingStack = GLOBAL_STATE.clippingStack;
+  const prevLayoutStack = GLOBAL_STATE.layoutStack;
+  const prevBackendDriver = GLOBAL_STATE.backendDriver;
+  const prevBackendFrame = GLOBAL_STATE.backendFrame;
+  const prevBackendEnvironment = GLOBAL_STATE.backendEnvironment;
+  let frame;
+  let frameSuccess = false;
+  let renderSeenIds;
+  let renderSeenKeys;
+  try {
+    const activeFrameSnapshot = frameSnapshot ?? (prevFrameSnapshot?.logicalTime === renderTimestamp ? prevFrameSnapshot : Object.freeze({
+      frameId: prevFrameSnapshot?.frameId ?? 0,
+      hostTime: prevFrameSnapshot?.hostTime ?? renderTimestamp,
+      logicalTime: renderTimestamp
+    }));
+    GLOBAL_STATE.frameSnapshot = activeFrameSnapshot;
+    GLOBAL_STATE.currentPibblInstance = pibblInstance;
+    for (const service of pibblInstance.optionalServices.values()) service.beginRender?.();
+    GLOBAL_STATE.renderTransaction = renderTransaction;
+    GLOBAL_STATE.currentPibblInstance.renderTimestamp = activeFrameSnapshot.logicalTime;
+    GLOBAL_STATE.canvas = canvas;
+    const rootNode = arguments.length >= 3 && updatedRoot !== NO_PENDING_ROOT ? updatedRoot : GLOBAL_STATE.currentPibblInstance.root;
+    GLOBAL_STATE.currentPibblInstance.root = rootNode;
+    const driver = pibblInstance.backendDriver;
+    GLOBAL_STATE.backendDriver = driver;
+    frame = driver.beginFrame({
+      canvas,
+      logicalWidth: pibblInstance.rootLayoutBox.width,
+      logicalHeight: pibblInstance.rootLayoutBox.height,
+      backingWidth: canvas.width,
+      backingHeight: canvas.height,
+      renderTimestamp: activeFrameSnapshot.logicalTime
+    });
+    if (!frame) {
+      pibblInstance.eventRoot.html?.suspend(pibblInstance);
+      finishTransaction(true);
+      return;
+    }
+    pibblInstance.eventRoot.html?.beginRender(pibblInstance);
+    GLOBAL_STATE.backendFrame = frame;
+    GLOBAL_STATE.backendEnvironment = frame.environment;
+    GLOBAL_STATE.renderContext = frame.context2D;
+    GLOBAL_STATE.renderTarget = frame.renderTarget;
+    GLOBAL_STATE.worldBaseTransform = frame.worldBaseTransform;
+    GLOBAL_STATE.worldExactTransform = void 0;
+    GLOBAL_STATE.worldPaintAnchorTransform = void 0;
+    GLOBAL_STATE.presentationTransformLineage = void 0;
+    GLOBAL_STATE.presentationTransformLineageTrackingDepth = 0;
+    if (frame.context2D !== void 0 && frame.renderTarget !== void 0 && frame.worldBaseTransform !== void 0) {
+      initializeCurrentWorldTransformAnchor(frame.worldBaseTransform);
+    }
+    GLOBAL_STATE.clippingStack = [];
+    const surface = pibblInstance.surface.snapshot;
+    const logicalWidth = surface?.logicalWidth ?? pibblInstance.rootLayoutBox.width;
+    const logicalHeight = surface?.logicalHeight ?? pibblInstance.rootLayoutBox.height;
+    const previousRootBox = pibblInstance.rootLayoutBox;
+    if (previousRootBox.width !== logicalWidth || previousRootBox.height !== logicalHeight) {
+      pibblInstance.rootLayoutBox = Object.freeze({
+        x: 0,
+        y: 0,
+        width: logicalWidth,
+        height: logicalHeight
+      });
+    }
+    GLOBAL_STATE.layoutStack = [{
+      allocation: pibblInstance.rootLayoutBox,
+      percentageBasis: pibblInstance.rootLayoutBox
+    }];
+    const renderGeneration = ++pibblInstance.renderGeneration;
+    renderSeenIds = pibblInstance.renderSeenIds;
+    renderSeenKeys = pibblInstance.renderSeenKeys;
+    renderSeenIds.clear();
+    renderSeenKeys.clear();
+    GLOBAL_STATE.seenIds = renderSeenIds;
+    GLOBAL_STATE.seenKeys = renderSeenKeys;
+    const id = "root";
+    renderSeenIds.add(id);
+    withSignalWriteForbidden(
+      "Pibbl render",
+      () => render(rootNode, id, void 0)
+    );
+    for (const [id2, componentRefs] of pibblInstance.refs) {
+      if (componentRefs.renderGeneration === renderGeneration) continue;
+      componentRefs.teardowns.execute();
+      pibblInstance.refs.delete(id2);
+    }
+    frameSuccess = true;
+    for (const service of pibblInstance.optionalServices.values()) service.endRender?.(true);
+    driver.finishFrame(frame, true);
+    finishTransaction(true);
+  } catch (error) {
+    for (const service of pibblInstance.optionalServices.values()) service.endRender?.(false);
+    finishTransaction(false);
+    for (const refs of pibblInstance.refs.values()) {
+      refs.teardowns.execute();
+    }
+    pibblInstance.refs.clear();
+    throw error;
+  } finally {
+    try {
+      if (frame && !frameSuccess) {
+        pibblInstance.backendDriver.finishFrame(frame, false);
+      }
+    } finally {
+      try {
+        clearTempState();
+        GLOBAL_STATE.clippingStack = prevClippingStack;
+        GLOBAL_STATE.layoutStack = prevLayoutStack;
+        if (ownsRenderTransaction) {
+          try {
+            finishTransaction(false);
+          } finally {
+            if (pibblInstance.eventRoot.renderTransaction === renderTransaction) {
+              pibblInstance.eventRoot.renderTransaction = void 0;
+            }
+          }
+        }
+      } finally {
+        renderSeenIds?.clear();
+        renderSeenKeys?.clear();
+        GLOBAL_STATE.currentPibblInstance = prevCurrentPibblInstance;
+        GLOBAL_STATE.canvas = prevCanvas;
+        GLOBAL_STATE.renderContext = prevRenderContext;
+        GLOBAL_STATE.renderTarget = prevRenderTarget;
+        GLOBAL_STATE.worldBaseTransform = prevWorldBaseTransform;
+        GLOBAL_STATE.worldExactTransform = prevWorldExactTransform;
+        GLOBAL_STATE.worldPaintAnchorTransform = prevWorldPaintAnchorTransform;
+        GLOBAL_STATE.presentationTransformLineage = prevPresentationTransformLineage;
+        GLOBAL_STATE.presentationTransformLineageTrackingDepth = prevPresentationTransformLineageTrackingDepth;
+        GLOBAL_STATE.renderTransaction = prevRenderTransaction;
+        GLOBAL_STATE.frameSnapshot = prevFrameSnapshot;
+        GLOBAL_STATE.primitiveReceiverToken = prevPrimitiveReceiverToken;
+        GLOBAL_STATE.seenIds = prevSeenIds;
+        GLOBAL_STATE.seenKeys = prevSeenKeys;
+        GLOBAL_STATE.componentRefs = prevComponentRefs;
+        GLOBAL_STATE.componentHookIndex = prevComponentHookIndex;
+        GLOBAL_STATE.componentIsMounting = prevComponentIsMounting;
+        GLOBAL_STATE.backendDriver = prevBackendDriver;
+        GLOBAL_STATE.backendFrame = prevBackendFrame;
+        GLOBAL_STATE.backendEnvironment = prevBackendEnvironment;
+      }
+    }
+  }
+}
+export {
+  executeRender
+};
+//# sourceMappingURL=execute-render.js.map

package/dist/lib/execute-render.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/execute-render.ts"],
+  "sourcesContent": ["import { RootRenderTransaction } from './render-transaction.js';\nimport {\n  clearTempState,\n  GLOBAL_STATE,\n  NO_PENDING_ROOT,\n} from './global-state.js';\nimport { render } from './render.js';\nimport { initializeCurrentWorldTransformAnchor } from './render-target.js';\nimport {\n  Canvas,\n  type PibblNode,\n} from './types.js';\nimport type {\n  PibblBackendFrame,\n} from './backend/types.js';\nimport type { PibblFrameSnapshot } from './scheduler/types.js';\nimport { withSignalWriteForbidden } from './signals/graph.js';\n\n/**\n * Gets the root element for a canvas and renders it. This is the\n * entry point for rendering the entire tree.\n * @param canvas The canvas to render on\n */\nexport function executeRender(\n  canvas: Canvas,\n  renderTimestamp: number,\n  updatedRoot?: PibblNode | typeof NO_PENDING_ROOT,\n  _updateParents = false,\n  frameSnapshot?: PibblFrameSnapshot,\n): void {\n  if (!canvas) {\n    throw new Error('No canvas element provided');\n  }\n\n  const pibblInstance = GLOBAL_STATE.pibblInstances.get(canvas);\n\n  if (!pibblInstance) {\n    throw new Error('Pibbl is not mounted on this element');\n  }\n\n  if (pibblInstance.mainTeardowns.closed) return;\n\n  const inheritedTransaction = pibblInstance.eventRoot.renderTransaction;\n  const renderTransaction = inheritedTransaction ?? new RootRenderTransaction();\n  const ownsRenderTransaction = !inheritedTransaction;\n  if (ownsRenderTransaction) {\n    pibblInstance.eventRoot.renderTransaction = renderTransaction;\n  }\n  let transactionFinished = false;\n  const finishTransaction = (success: boolean) => {\n    if (!ownsRenderTransaction || transactionFinished) return;\n    transactionFinished = true;\n    (renderTransaction as RootRenderTransaction).finish(success);\n  };\n\n  const prevCurrentPibblInstance = GLOBAL_STATE.currentPibblInstance;\n  const prevCanvas = GLOBAL_STATE.canvas;\n  const prevRenderContext = GLOBAL_STATE.renderContext;\n  const prevRenderTarget = GLOBAL_STATE.renderTarget;\n  const prevWorldBaseTransform = GLOBAL_STATE.worldBaseTransform;\n  const prevWorldExactTransform = GLOBAL_STATE.worldExactTransform;\n  const prevWorldPaintAnchorTransform = GLOBAL_STATE.worldPaintAnchorTransform;\n  const prevPresentationTransformLineage = GLOBAL_STATE.presentationTransformLineage;\n  const prevPresentationTransformLineageTrackingDepth =\n    GLOBAL_STATE.presentationTransformLineageTrackingDepth;\n  const prevRenderTransaction = GLOBAL_STATE.renderTransaction;\n  const prevFrameSnapshot = GLOBAL_STATE.frameSnapshot;\n  const prevPrimitiveReceiverToken = GLOBAL_STATE.primitiveReceiverToken;\n  const prevSeenIds = GLOBAL_STATE.seenIds;\n  const prevSeenKeys = GLOBAL_STATE.seenKeys;\n  const prevComponentRefs = GLOBAL_STATE.componentRefs;\n  const prevComponentHookIndex = GLOBAL_STATE.componentHookIndex;\n  const prevComponentIsMounting = GLOBAL_STATE.componentIsMounting;\n  const prevClippingStack = GLOBAL_STATE.clippingStack;\n  const prevLayoutStack = GLOBAL_STATE.layoutStack;\n  const prevBackendDriver = GLOBAL_STATE.backendDriver;\n  const prevBackendFrame = GLOBAL_STATE.backendFrame;\n  const prevBackendEnvironment = GLOBAL_STATE.backendEnvironment;\n  let frame: PibblBackendFrame<unknown> | undefined;\n  let frameSuccess = false;\n  let renderSeenIds: Set<string> | undefined;\n  let renderSeenKeys: Set<string> | undefined;\n  try {\n    const activeFrameSnapshot = frameSnapshot ?? (\n      prevFrameSnapshot?.logicalTime === renderTimestamp ?\n        prevFrameSnapshot :\n        Object.freeze({\n          frameId: prevFrameSnapshot?.frameId ?? 0,\n          hostTime: prevFrameSnapshot?.hostTime ?? renderTimestamp,\n          logicalTime: renderTimestamp,\n        })\n    );\n    GLOBAL_STATE.frameSnapshot = activeFrameSnapshot;\n    GLOBAL_STATE.currentPibblInstance = pibblInstance;\n    for (const service of pibblInstance.optionalServices.values()) service.beginRender?.();\n    GLOBAL_STATE.renderTransaction = renderTransaction;\n    GLOBAL_STATE.currentPibblInstance.renderTimestamp = activeFrameSnapshot.logicalTime;\n    GLOBAL_STATE.canvas = canvas;\n    const rootNode = arguments.length >= 3 && updatedRoot !== NO_PENDING_ROOT ?\n      updatedRoot :\n      GLOBAL_STATE.currentPibblInstance.root;\n    GLOBAL_STATE.currentPibblInstance.root = rootNode;\n    const driver = pibblInstance.backendDriver;\n    GLOBAL_STATE.backendDriver = driver;\n    frame = driver.beginFrame({\n      canvas,\n      logicalWidth: pibblInstance.rootLayoutBox.width,\n      logicalHeight: pibblInstance.rootLayoutBox.height,\n      backingWidth: canvas.width,\n      backingHeight: canvas.height,\n      renderTimestamp: activeFrameSnapshot.logicalTime,\n    });\n    if (!frame) {\n      pibblInstance.eventRoot.html?.suspend(pibblInstance);\n      finishTransaction(true);\n      return;\n    }\n    pibblInstance.eventRoot.html?.beginRender(pibblInstance);\n    GLOBAL_STATE.backendFrame = frame;\n    GLOBAL_STATE.backendEnvironment = frame.environment;\n    GLOBAL_STATE.renderContext = frame.context2D;\n    GLOBAL_STATE.renderTarget = frame.renderTarget;\n    GLOBAL_STATE.worldBaseTransform = frame.worldBaseTransform;\n    GLOBAL_STATE.worldExactTransform = undefined;\n    GLOBAL_STATE.worldPaintAnchorTransform = undefined;\n    GLOBAL_STATE.presentationTransformLineage = undefined;\n    GLOBAL_STATE.presentationTransformLineageTrackingDepth = 0;\n    if (\n      frame.context2D !== undefined &&\n      frame.renderTarget !== undefined &&\n      frame.worldBaseTransform !== undefined\n    ) {\n      initializeCurrentWorldTransformAnchor(frame.worldBaseTransform);\n    }\n    GLOBAL_STATE.clippingStack = [];\n    const surface = pibblInstance.surface.snapshot;\n    const logicalWidth = surface?.logicalWidth ?? pibblInstance.rootLayoutBox.width;\n    const logicalHeight = surface?.logicalHeight ?? pibblInstance.rootLayoutBox.height;\n    const previousRootBox = pibblInstance.rootLayoutBox;\n    if (\n      previousRootBox.width !== logicalWidth ||\n      previousRootBox.height !== logicalHeight\n    ) {\n      pibblInstance.rootLayoutBox = Object.freeze({\n        x: 0,\n        y: 0,\n        width: logicalWidth,\n        height: logicalHeight,\n      });\n    }\n    GLOBAL_STATE.layoutStack = [{\n      allocation: pibblInstance.rootLayoutBox,\n      percentageBasis: pibblInstance.rootLayoutBox,\n    }];\n\n    const renderGeneration = ++pibblInstance.renderGeneration;\n    renderSeenIds = pibblInstance.renderSeenIds;\n    renderSeenKeys = pibblInstance.renderSeenKeys;\n    renderSeenIds.clear();\n    renderSeenKeys.clear();\n    GLOBAL_STATE.seenIds = renderSeenIds;\n    GLOBAL_STATE.seenKeys = renderSeenKeys;\n    const id = 'root';\n    renderSeenIds.add(id);\n    withSignalWriteForbidden(\n      'Pibbl render',\n      () => render(rootNode, id, undefined),\n    );\n\n    for (const [id, componentRefs] of pibblInstance.refs) {\n      if (componentRefs.renderGeneration === renderGeneration) continue;\n      componentRefs.teardowns.execute();\n      pibblInstance.refs.delete(id);\n    }\n    frameSuccess = true;\n    for (const service of pibblInstance.optionalServices.values()) service.endRender?.(true);\n    driver.finishFrame(frame, true);\n    finishTransaction(true);\n  } catch (error) {\n    for (const service of pibblInstance.optionalServices.values()) service.endRender?.(false);\n    finishTransaction(false);\n    for (const refs of pibblInstance.refs.values()) {\n      refs.teardowns.execute();\n    }\n    pibblInstance.refs.clear();\n    throw error;\n  } finally {\n    try {\n      if (frame && !frameSuccess) {\n        pibblInstance.backendDriver.finishFrame(frame, false);\n      }\n    } finally {\n      try {\n        clearTempState();\n        GLOBAL_STATE.clippingStack = prevClippingStack;\n        GLOBAL_STATE.layoutStack = prevLayoutStack;\n        if (ownsRenderTransaction) {\n          try {\n            finishTransaction(false);\n          } finally {\n            if (pibblInstance.eventRoot.renderTransaction === renderTransaction) {\n              pibblInstance.eventRoot.renderTransaction = undefined;\n            }\n          }\n        }\n      } finally {\n        renderSeenIds?.clear();\n        renderSeenKeys?.clear();\n        GLOBAL_STATE.currentPibblInstance = prevCurrentPibblInstance;\n        GLOBAL_STATE.canvas = prevCanvas;\n        GLOBAL_STATE.renderContext = prevRenderContext;\n        GLOBAL_STATE.renderTarget = prevRenderTarget;\n        GLOBAL_STATE.worldBaseTransform = prevWorldBaseTransform;\n        GLOBAL_STATE.worldExactTransform = prevWorldExactTransform;\n        GLOBAL_STATE.worldPaintAnchorTransform = prevWorldPaintAnchorTransform;\n        GLOBAL_STATE.presentationTransformLineage = prevPresentationTransformLineage;\n        GLOBAL_STATE.presentationTransformLineageTrackingDepth =\n          prevPresentationTransformLineageTrackingDepth;\n        GLOBAL_STATE.renderTransaction = prevRenderTransaction;\n        GLOBAL_STATE.frameSnapshot = prevFrameSnapshot;\n        GLOBAL_STATE.primitiveReceiverToken = prevPrimitiveReceiverToken;\n        GLOBAL_STATE.seenIds = prevSeenIds;\n        GLOBAL_STATE.seenKeys = prevSeenKeys;\n        GLOBAL_STATE.componentRefs = prevComponentRefs;\n        GLOBAL_STATE.componentHookIndex = prevComponentHookIndex;\n        GLOBAL_STATE.componentIsMounting = prevComponentIsMounting;\n        GLOBAL_STATE.backendDriver = prevBackendDriver;\n        GLOBAL_STATE.backendFrame = prevBackendFrame;\n        GLOBAL_STATE.backendEnvironment = prevBackendEnvironment;\n      }\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["id"]
+}

package/dist/lib/filter/canvas-state.d.ts

@@ -0,0 +1,2 @@
+import type { RenderingContext2D } from '../types.js';
+export declare function copyFilterSourceState(parent: RenderingContext2D, source: RenderingContext2D): void;

package/dist/lib/filter/canvas-state.js

@@ -0,0 +1,31 @@
+function copyFilterSourceState(parent, source) {
+  source.direction = parent.direction;
+  source.fillStyle = parent.fillStyle;
+  source.font = parent.font;
+  copyIfPresent(parent, source, "fontKerning");
+  copyIfPresent(parent, source, "fontStretch");
+  copyIfPresent(parent, source, "fontVariantCaps");
+  source.imageSmoothingEnabled = parent.imageSmoothingEnabled;
+  source.imageSmoothingQuality = parent.imageSmoothingQuality;
+  copyIfPresent(parent, source, "letterSpacing");
+  source.lineCap = parent.lineCap;
+  source.setLineDash(parent.getLineDash());
+  source.lineDashOffset = parent.lineDashOffset;
+  source.lineJoin = parent.lineJoin;
+  source.lineWidth = parent.lineWidth;
+  source.miterLimit = parent.miterLimit;
+  source.strokeStyle = parent.strokeStyle;
+  source.textAlign = parent.textAlign;
+  source.textBaseline = parent.textBaseline;
+  copyIfPresent(parent, source, "textRendering");
+  copyIfPresent(parent, source, "wordSpacing");
+}
+function copyIfPresent(parent, source, property) {
+  if (property in parent && property in source) {
+    source[property] = parent[property];
+  }
+}
+export {
+  copyFilterSourceState
+};
+//# sourceMappingURL=canvas-state.js.map

package/dist/lib/filter/canvas-state.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/filter/canvas-state.ts"],
+  "sourcesContent": ["import type { RenderingContext2D } from '../types.js';\n\nexport function copyFilterSourceState(\n  parent: RenderingContext2D,\n  source: RenderingContext2D,\n): void {\n  source.direction = parent.direction;\n  source.fillStyle = parent.fillStyle;\n  source.font = parent.font;\n  copyIfPresent(parent, source, 'fontKerning');\n  copyIfPresent(parent, source, 'fontStretch');\n  copyIfPresent(parent, source, 'fontVariantCaps');\n  source.imageSmoothingEnabled = parent.imageSmoothingEnabled;\n  source.imageSmoothingQuality = parent.imageSmoothingQuality;\n  copyIfPresent(parent, source, 'letterSpacing');\n  source.lineCap = parent.lineCap;\n  source.setLineDash(parent.getLineDash());\n  source.lineDashOffset = parent.lineDashOffset;\n  source.lineJoin = parent.lineJoin;\n  source.lineWidth = parent.lineWidth;\n  source.miterLimit = parent.miterLimit;\n  source.strokeStyle = parent.strokeStyle;\n  source.textAlign = parent.textAlign;\n  source.textBaseline = parent.textBaseline;\n  copyIfPresent(parent, source, 'textRendering');\n  copyIfPresent(parent, source, 'wordSpacing');\n}\n\nfunction copyIfPresent(\n  parent: RenderingContext2D,\n  source: RenderingContext2D,\n  property: string,\n): void {\n  if (property in parent && property in source) {\n    (source as unknown as Record<string, unknown>)[property] =\n      (parent as unknown as Record<string, unknown>)[property];\n  }\n}\n"],
+  "mappings": "AAEO,SAAS,sBACd,QACA,QACM;AACN,SAAO,YAAY,OAAO;AAC1B,SAAO,YAAY,OAAO;AAC1B,SAAO,OAAO,OAAO;AACrB,gBAAc,QAAQ,QAAQ,aAAa;AAC3C,gBAAc,QAAQ,QAAQ,aAAa;AAC3C,gBAAc,QAAQ,QAAQ,iBAAiB;AAC/C,SAAO,wBAAwB,OAAO;AACtC,SAAO,wBAAwB,OAAO;AACtC,gBAAc,QAAQ,QAAQ,eAAe;AAC7C,SAAO,UAAU,OAAO;AACxB,SAAO,YAAY,OAAO,YAAY,CAAC;AACvC,SAAO,iBAAiB,OAAO;AAC/B,SAAO,WAAW,OAAO;AACzB,SAAO,YAAY,OAAO;AAC1B,SAAO,aAAa,OAAO;AAC3B,SAAO,cAAc,OAAO;AAC5B,SAAO,YAAY,OAAO;AAC1B,SAAO,eAAe,OAAO;AAC7B,gBAAc,QAAQ,QAAQ,eAAe;AAC7C,gBAAc,QAAQ,QAAQ,aAAa;AAC7C;AAEA,SAAS,cACP,QACA,QACA,UACM;AACN,MAAI,YAAY,UAAU,YAAY,QAAQ;AAC5C,IAAC,OAA8C,QAAQ,IACpD,OAA8C,QAAQ;AAAA,EAC3D;AACF;",
+  "names": []
+}

package/dist/lib/filter/filter-region.d.ts

@@ -0,0 +1,33 @@
+import type { LayoutBox } from '../layout/types.js';
+import type { RenderTargetSnapshot } from '../render-target.js';
+import type { NativePreparedFilter } from '../../filters/native-operations.js';
+export declare const BLUR_EXTENT_FACTOR: number;
+export interface PixelBounds {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface FilterPixelWindow {
+    readonly logicalBounds: Readonly<LayoutBox>;
+    readonly backingX: number;
+    readonly backingY: number;
+    readonly backingWidth: number;
+    readonly backingHeight: number;
+    readonly renderTransform: DOMMatrix;
+    readonly inverseRenderTransform: DOMMatrix;
+}
+export interface FilterWindows {
+    readonly source: FilterPixelWindow;
+    readonly output: FilterPixelWindow;
+    readonly density: number;
+    readonly sourceToOutputX: number;
+    readonly sourceToOutputY: number;
+}
+export declare function reverseFilterInfluence(output: Readonly<PixelBounds>, filters: {
+    readonly values: readonly NativePreparedFilter[];
+}, density: number): PixelBounds;
+export declare function largestAffineScale(matrix: DOMMatrixReadOnly): number;
+export declare function resolveFilterWindows(parentTarget: RenderTargetSnapshot, parentPaintTransform: DOMMatrixReadOnly, filters: {
+    readonly values: readonly NativePreparedFilter[];
+}): FilterWindows | 'discard';

package/dist/lib/filter/filter-region.js

@@ -0,0 +1,291 @@
+import { GLOBAL_STATE } from "../global-state.js";
+import { layoutDiagnostic } from "../style/diagnostics.js";
+const BLUR_EXTENT_FACTOR = 3 * Math.sqrt(2 * Math.PI) / 4;
+const MAX_UNSIGNED_LONG = 4294967295;
+function reverseFilterInfluence(output, filters, density) {
+  let left = output.x;
+  let top = output.y;
+  let right = output.x + output.width;
+  let bottom = output.y + output.height;
+  assertPixelEdges(left, top, right, bottom);
+  for (let index = filters.values.length - 1; index >= 0; index -= 1) {
+    const filter = filters.values[index];
+    const influenced = filter.reverseInfluence({
+      x: left,
+      y: top,
+      width: right - left,
+      height: bottom - top
+    }, density);
+    left = influenced.x;
+    top = influenced.y;
+    right = influenced.x + influenced.width;
+    bottom = influenced.y + influenced.height;
+    assertPixelEdges(left, top, right, bottom);
+  }
+  return {
+    x: left,
+    y: top,
+    width: right - left,
+    height: bottom - top
+  };
+}
+function largestAffineScale(matrix) {
+  const { a, b, c, d } = matrix;
+  const coefficientScale = Math.max(
+    Math.abs(a),
+    Math.abs(b),
+    Math.abs(c),
+    Math.abs(d)
+  );
+  if (coefficientScale === 0) return 0;
+  if (!Number.isFinite(coefficientScale)) return Number.NaN;
+  const normalizedA = a / coefficientScale;
+  const normalizedB = b / coefficientScale;
+  const normalizedC = c / coefficientScale;
+  const normalizedD = d / coefficientScale;
+  const sumOfSquares = normalizedA * normalizedA + normalizedB * normalizedB + normalizedC * normalizedC + normalizedD * normalizedD;
+  const determinant = normalizedA * normalizedD - normalizedB * normalizedC;
+  const discriminant = Math.max(
+    0,
+    sumOfSquares * sumOfSquares - 4 * determinant * determinant
+  );
+  return coefficientScale * Math.sqrt((sumOfSquares + Math.sqrt(discriminant)) / 2);
+}
+function resolveFilterWindows(parentTarget, parentPaintTransform, filters) {
+  if (!isFiniteAffine(parentPaintTransform)) return "discard";
+  const inverseProject = createInverseProjector(parentPaintTransform);
+  if (!inverseProject) return "discard";
+  const localToParentBacking = parentTarget.renderTransform.multiply(
+    parentPaintTransform
+  );
+  if (!isFiniteAffine(localToParentBacking)) return "discard";
+  const density = largestAffineScale(localToParentBacking);
+  if (!Number.isFinite(density) || density <= 0) return "discard";
+  const projected = projectBounds(parentTarget.logicalBounds, inverseProject);
+  if (!projected) return "discard";
+  const outputPixels = snapToBackingPixels(projected, density);
+  const sourcePixels = reverseFilterInfluence(outputPixels, filters, density);
+  assertCanvasPixelBounds(outputPixels);
+  assertCanvasPixelBounds(sourcePixels);
+  const output = createWindow(outputPixels, density);
+  const source = createWindow(sourcePixels, density);
+  if (!output || !source) return "discard";
+  return {
+    source,
+    output,
+    density,
+    sourceToOutputX: source.backingX - output.backingX,
+    sourceToOutputY: source.backingY - output.backingY
+  };
+}
+function projectBounds(bounds, inverseProject) {
+  const right = bounds.x + bounds.width;
+  const bottom = bounds.y + bounds.height;
+  if (![bounds.x, bounds.y, right, bottom].every(Number.isFinite)) {
+    return void 0;
+  }
+  const points = [
+    inverseProject(bounds.x, bounds.y),
+    inverseProject(right, bounds.y),
+    inverseProject(bounds.x, bottom),
+    inverseProject(right, bottom)
+  ];
+  if (points.some((point) => !point)) return void 0;
+  const projectedPoints = points;
+  if (projectedPoints.some(
+    (point) => !Number.isFinite(point.x) || !Number.isFinite(point.y)
+  )) {
+    return void 0;
+  }
+  const xs = projectedPoints.map((point) => point.x);
+  const ys = projectedPoints.map((point) => point.y);
+  const left = Math.min(...xs);
+  const top = Math.min(...ys);
+  const projectedRight = Math.max(...xs);
+  const projectedBottom = Math.max(...ys);
+  return {
+    x: left,
+    y: top,
+    width: projectedRight - left,
+    height: projectedBottom - top
+  };
+}
+function createInverseProjector(matrix) {
+  const { a, b, c, d, e, f } = matrix;
+  const firstRowScale = Math.max(Math.abs(a), Math.abs(c));
+  const secondRowScale = Math.max(Math.abs(b), Math.abs(d));
+  if (firstRowScale === 0 || secondRowScale === 0) return void 0;
+  const rowA = a / firstRowScale;
+  const rowB = b / secondRowScale;
+  const rowC = c / firstRowScale;
+  const rowD = d / secondRowScale;
+  const firstColumnScale = Math.max(Math.abs(rowA), Math.abs(rowB));
+  const secondColumnScale = Math.max(Math.abs(rowC), Math.abs(rowD));
+  if (firstColumnScale === 0 || secondColumnScale === 0) return void 0;
+  const normalizedA = rowA / firstColumnScale;
+  const normalizedB = rowB / firstColumnScale;
+  const normalizedC = rowC / secondColumnScale;
+  const normalizedD = rowD / secondColumnScale;
+  if (Math.abs(normalizedA) >= Math.abs(normalizedB)) {
+    if (normalizedA === 0) return void 0;
+    const ratio2 = normalizedB / normalizedA;
+    const schurComplement2 = normalizedD - ratio2 * normalizedC;
+    if (schurComplement2 === 0 || !Number.isFinite(schurComplement2)) {
+      return void 0;
+    }
+    return (parentX, parentY) => {
+      const rightX = scaledDifference(parentX, e, firstRowScale);
+      const rightY = scaledDifference(parentY, f, secondRowScale);
+      const normalizedY = (rightY - ratio2 * rightX) / schurComplement2;
+      const normalizedX = (rightX - normalizedC * normalizedY) / normalizedA;
+      const x = normalizedX / firstColumnScale;
+      const y = normalizedY / secondColumnScale;
+      return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : void 0;
+    };
+  }
+  const ratio = normalizedA / normalizedB;
+  const schurComplement = normalizedC - ratio * normalizedD;
+  if (schurComplement === 0 || !Number.isFinite(schurComplement)) {
+    return void 0;
+  }
+  return (parentX, parentY) => {
+    const rightX = scaledDifference(parentX, e, firstRowScale);
+    const rightY = scaledDifference(parentY, f, secondRowScale);
+    const normalizedY = (rightX - ratio * rightY) / schurComplement;
+    const normalizedX = (rightY - normalizedD * normalizedY) / normalizedB;
+    const x = normalizedX / firstColumnScale;
+    const y = normalizedY / secondColumnScale;
+    return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : void 0;
+  };
+}
+function scaledDifference(value, offset, scale) {
+  const difference = value - offset;
+  if (Number.isFinite(difference)) return difference / scale;
+  return value / scale - offset / scale;
+}
+function snapToBackingPixels(bounds, density) {
+  const scaledLeft = bounds.x * density;
+  const scaledTop = bounds.y * density;
+  const scaledRight = (bounds.x + bounds.width) * density;
+  const scaledBottom = (bounds.y + bounds.height) * density;
+  if (![scaledLeft, scaledTop, scaledRight, scaledBottom].every(Number.isFinite)) {
+    throw filterRegionError(
+      { scaledLeft, scaledTop, scaledRight, scaledBottom },
+      "filter backing edge arithmetic overflowed"
+    );
+  }
+  const left = Math.floor(scaledLeft);
+  const top = Math.floor(scaledTop);
+  const right = Math.ceil(scaledRight);
+  const bottom = Math.ceil(scaledBottom);
+  assertPixelEdges(left, top, right, bottom);
+  return {
+    x: left,
+    y: top,
+    width: right - left,
+    height: bottom - top
+  };
+}
+function createWindow(pixels, density) {
+  const inverseDensity = 1 / density;
+  const logicalBounds = {
+    x: pixels.x / density,
+    y: pixels.y / density,
+    width: pixels.width / density,
+    height: pixels.height / density
+  };
+  const inverseOriginX = pixels.x / density;
+  const inverseOriginY = pixels.y / density;
+  if (!Number.isFinite(inverseDensity) || inverseDensity <= 0 || !Object.values(logicalBounds).every(Number.isFinite) || !Number.isFinite(inverseOriginX) || !Number.isFinite(inverseOriginY)) {
+    return void 0;
+  }
+  const renderTransform = new DOMMatrix([
+    density,
+    0,
+    0,
+    density,
+    -pixels.x,
+    -pixels.y
+  ]);
+  const inverseRenderTransform = new DOMMatrix([
+    inverseDensity,
+    0,
+    0,
+    inverseDensity,
+    inverseOriginX,
+    inverseOriginY
+  ]);
+  if (!isFiniteAffine(renderTransform) || !isFiniteAffine(inverseRenderTransform)) {
+    return void 0;
+  }
+  return {
+    logicalBounds: Object.freeze(logicalBounds),
+    backingX: pixels.x,
+    backingY: pixels.y,
+    backingWidth: pixels.width,
+    backingHeight: pixels.height,
+    renderTransform,
+    inverseRenderTransform
+  };
+}
+function assertPixelEdges(left, top, right, bottom) {
+  const edges = { left, top, right, bottom };
+  if (!Object.values(edges).every(Number.isSafeInteger)) {
+    throw filterRegionError(
+      edges,
+      "filter backing edges must remain finite safe integers"
+    );
+  }
+  const width = right - left;
+  const height = bottom - top;
+  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height)) {
+    throw filterRegionError(
+      { width, height },
+      "filter backing dimensions must remain finite safe integers"
+    );
+  }
+}
+function assertCanvasPixelBounds(bounds) {
+  const { width, height } = bounds;
+  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0 || width > MAX_UNSIGNED_LONG || height > MAX_UNSIGNED_LONG) {
+    throw filterRegionError(
+      { width, height },
+      `filter backing dimensions must be positive unsigned-long integers no greater than ${MAX_UNSIGNED_LONG}`
+    );
+  }
+  const area = width * height;
+  if (!Number.isSafeInteger(area)) {
+    throw filterRegionError(
+      area,
+      "filter backing area must remain a finite safe integer"
+    );
+  }
+}
+function isFiniteAffine(matrix) {
+  return matrix.is2D && [
+    matrix.a,
+    matrix.b,
+    matrix.c,
+    matrix.d,
+    matrix.e,
+    matrix.f
+  ].every(Number.isFinite);
+}
+function filterRegionError(value, reason) {
+  const type = GLOBAL_STATE.componentRefs?.element.type;
+  const component = typeof type === "function" && type.name ? type.name : "filter boundary";
+  return layoutDiagnostic({
+    component,
+    property: "filter.backingDimensions",
+    value,
+    algorithm: "filter-capture",
+    reason
+  });
+}
+export {
+  BLUR_EXTENT_FACTOR,
+  largestAffineScale,
+  resolveFilterWindows,
+  reverseFilterInfluence
+};
+//# sourceMappingURL=filter-region.js.map

package/dist/lib/filter/filter-region.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/filter/filter-region.ts"],
+  "sourcesContent": ["import { GLOBAL_STATE } from '../global-state.js';\nimport type { LayoutBox } from '../layout/types.js';\nimport type { RenderTargetSnapshot } from '../render-target.js';\nimport { layoutDiagnostic } from '../style/diagnostics.js';\nimport type { NativePreparedFilter } from '../../filters/native-operations.js';\n\nexport const BLUR_EXTENT_FACTOR = (3 * Math.sqrt(2 * Math.PI)) / 4;\n\nconst MAX_UNSIGNED_LONG = 0xffff_ffff;\n\nexport interface PixelBounds {\n  readonly x: number;\n  readonly y: number;\n  readonly width: number;\n  readonly height: number;\n}\n\nexport interface FilterPixelWindow {\n  readonly logicalBounds: Readonly<LayoutBox>;\n  readonly backingX: number;\n  readonly backingY: number;\n  readonly backingWidth: number;\n  readonly backingHeight: number;\n  readonly renderTransform: DOMMatrix;\n  readonly inverseRenderTransform: DOMMatrix;\n}\n\nexport interface FilterWindows {\n  readonly source: FilterPixelWindow;\n  readonly output: FilterPixelWindow;\n  readonly density: number;\n  readonly sourceToOutputX: number;\n  readonly sourceToOutputY: number;\n}\n\nexport function reverseFilterInfluence(\n  output: Readonly<PixelBounds>,\n  filters: { readonly values: readonly NativePreparedFilter[] },\n  density: number,\n): PixelBounds {\n  let left = output.x;\n  let top = output.y;\n  let right = output.x + output.width;\n  let bottom = output.y + output.height;\n  assertPixelEdges(left, top, right, bottom);\n\n  for (let index = filters.values.length - 1; index >= 0; index -= 1) {\n    const filter = filters.values[index]!;\n    const influenced = filter.reverseInfluence({\n      x: left,\n      y: top,\n      width: right - left,\n      height: bottom - top,\n    }, density);\n    left = influenced.x;\n    top = influenced.y;\n    right = influenced.x + influenced.width;\n    bottom = influenced.y + influenced.height;\n    assertPixelEdges(left, top, right, bottom);\n  }\n\n  return {\n    x: left,\n    y: top,\n    width: right - left,\n    height: bottom - top,\n  };\n}\n\nexport function largestAffineScale(matrix: DOMMatrixReadOnly): number {\n  const { a, b, c, d } = matrix;\n  const coefficientScale = Math.max(\n    Math.abs(a),\n    Math.abs(b),\n    Math.abs(c),\n    Math.abs(d),\n  );\n  if (coefficientScale === 0) return 0;\n  if (!Number.isFinite(coefficientScale)) return Number.NaN;\n\n  const normalizedA = a / coefficientScale;\n  const normalizedB = b / coefficientScale;\n  const normalizedC = c / coefficientScale;\n  const normalizedD = d / coefficientScale;\n  const sumOfSquares =\n    normalizedA * normalizedA + normalizedB * normalizedB +\n    normalizedC * normalizedC + normalizedD * normalizedD;\n  const determinant =\n    normalizedA * normalizedD - normalizedB * normalizedC;\n  const discriminant = Math.max(\n    0,\n    sumOfSquares * sumOfSquares - 4 * determinant * determinant,\n  );\n  return coefficientScale *\n    Math.sqrt((sumOfSquares + Math.sqrt(discriminant)) / 2);\n}\n\nexport function resolveFilterWindows(\n  parentTarget: RenderTargetSnapshot,\n  parentPaintTransform: DOMMatrixReadOnly,\n  filters: { readonly values: readonly NativePreparedFilter[] },\n): FilterWindows | 'discard' {\n  if (!isFiniteAffine(parentPaintTransform)) return 'discard';\n  const inverseProject = createInverseProjector(parentPaintTransform);\n  if (!inverseProject) return 'discard';\n\n  const localToParentBacking = parentTarget.renderTransform.multiply(\n    parentPaintTransform,\n  );\n  if (!isFiniteAffine(localToParentBacking)) return 'discard';\n  const density = largestAffineScale(localToParentBacking);\n  if (!Number.isFinite(density) || density <= 0) return 'discard';\n\n  const projected = projectBounds(parentTarget.logicalBounds, inverseProject);\n  if (!projected) return 'discard';\n  const outputPixels = snapToBackingPixels(projected, density);\n  const sourcePixels = reverseFilterInfluence(outputPixels, filters, density);\n  assertCanvasPixelBounds(outputPixels);\n  assertCanvasPixelBounds(sourcePixels);\n\n  const output = createWindow(outputPixels, density);\n  const source = createWindow(sourcePixels, density);\n  if (!output || !source) return 'discard';\n  return {\n    source,\n    output,\n    density,\n    sourceToOutputX: source.backingX - output.backingX,\n    sourceToOutputY: source.backingY - output.backingY,\n  };\n}\n\nfunction projectBounds(\n  bounds: Readonly<LayoutBox>,\n  inverseProject: InverseProjector,\n): LayoutBox | undefined {\n  const right = bounds.x + bounds.width;\n  const bottom = bounds.y + bounds.height;\n  if (![bounds.x, bounds.y, right, bottom].every(Number.isFinite)) {\n    return undefined;\n  }\n\n  const points = [\n    inverseProject(bounds.x, bounds.y),\n    inverseProject(right, bounds.y),\n    inverseProject(bounds.x, bottom),\n    inverseProject(right, bottom),\n  ];\n  if (points.some(point => !point)) return undefined;\n  const projectedPoints = points as readonly ProjectedPoint[];\n  if (projectedPoints.some(\n    point => !Number.isFinite(point.x) || !Number.isFinite(point.y),\n  )) {\n    return undefined;\n  }\n  const xs = projectedPoints.map(point => point.x);\n  const ys = projectedPoints.map(point => point.y);\n  const left = Math.min(...xs);\n  const top = Math.min(...ys);\n  const projectedRight = Math.max(...xs);\n  const projectedBottom = Math.max(...ys);\n  return {\n    x: left,\n    y: top,\n    width: projectedRight - left,\n    height: projectedBottom - top,\n  };\n}\n\ninterface ProjectedPoint {\n  readonly x: number;\n  readonly y: number;\n}\n\ntype InverseProjector = (\n  parentX: number,\n  parentY: number,\n) => ProjectedPoint | undefined;\n\nfunction createInverseProjector(\n  matrix: DOMMatrixReadOnly,\n): InverseProjector | undefined {\n  const { a, b, c, d, e, f } = matrix;\n  const firstRowScale = Math.max(Math.abs(a), Math.abs(c));\n  const secondRowScale = Math.max(Math.abs(b), Math.abs(d));\n  if (firstRowScale === 0 || secondRowScale === 0) return undefined;\n\n  const rowA = a / firstRowScale;\n  const rowB = b / secondRowScale;\n  const rowC = c / firstRowScale;\n  const rowD = d / secondRowScale;\n  const firstColumnScale = Math.max(Math.abs(rowA), Math.abs(rowB));\n  const secondColumnScale = Math.max(Math.abs(rowC), Math.abs(rowD));\n  if (firstColumnScale === 0 || secondColumnScale === 0) return undefined;\n\n  const normalizedA = rowA / firstColumnScale;\n  const normalizedB = rowB / firstColumnScale;\n  const normalizedC = rowC / secondColumnScale;\n  const normalizedD = rowD / secondColumnScale;\n  if (Math.abs(normalizedA) >= Math.abs(normalizedB)) {\n    if (normalizedA === 0) return undefined;\n    const ratio = normalizedB / normalizedA;\n    const schurComplement = normalizedD - ratio * normalizedC;\n    if (schurComplement === 0 || !Number.isFinite(schurComplement)) {\n      return undefined;\n    }\n    return (parentX, parentY) => {\n      const rightX = scaledDifference(parentX, e, firstRowScale);\n      const rightY = scaledDifference(parentY, f, secondRowScale);\n      const normalizedY =\n        (rightY - ratio * rightX) / schurComplement;\n      const normalizedX =\n        (rightX - normalizedC * normalizedY) / normalizedA;\n      const x = normalizedX / firstColumnScale;\n      const y = normalizedY / secondColumnScale;\n      return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : undefined;\n    };\n  }\n\n  const ratio = normalizedA / normalizedB;\n  const schurComplement = normalizedC - ratio * normalizedD;\n  if (schurComplement === 0 || !Number.isFinite(schurComplement)) {\n    return undefined;\n  }\n  return (parentX, parentY) => {\n    const rightX = scaledDifference(parentX, e, firstRowScale);\n    const rightY = scaledDifference(parentY, f, secondRowScale);\n    const normalizedY = (rightX - ratio * rightY) / schurComplement;\n    const normalizedX =\n      (rightY - normalizedD * normalizedY) / normalizedB;\n    const x = normalizedX / firstColumnScale;\n    const y = normalizedY / secondColumnScale;\n    return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : undefined;\n  };\n}\n\nfunction scaledDifference(\n  value: number,\n  offset: number,\n  scale: number,\n): number {\n  const difference = value - offset;\n  if (Number.isFinite(difference)) return difference / scale;\n  return value / scale - offset / scale;\n}\n\nfunction snapToBackingPixels(\n  bounds: Readonly<LayoutBox>,\n  density: number,\n): PixelBounds {\n  const scaledLeft = bounds.x * density;\n  const scaledTop = bounds.y * density;\n  const scaledRight = (bounds.x + bounds.width) * density;\n  const scaledBottom = (bounds.y + bounds.height) * density;\n  if (![scaledLeft, scaledTop, scaledRight, scaledBottom].every(Number.isFinite)) {\n    throw filterRegionError(\n      { scaledLeft, scaledTop, scaledRight, scaledBottom },\n      'filter backing edge arithmetic overflowed',\n    );\n  }\n  const left = Math.floor(scaledLeft);\n  const top = Math.floor(scaledTop);\n  const right = Math.ceil(scaledRight);\n  const bottom = Math.ceil(scaledBottom);\n  assertPixelEdges(left, top, right, bottom);\n  return {\n    x: left,\n    y: top,\n    width: right - left,\n    height: bottom - top,\n  };\n}\n\nfunction createWindow(\n  pixels: Readonly<PixelBounds>,\n  density: number,\n): FilterPixelWindow | undefined {\n  const inverseDensity = 1 / density;\n  const logicalBounds = {\n    x: pixels.x / density,\n    y: pixels.y / density,\n    width: pixels.width / density,\n    height: pixels.height / density,\n  };\n  const inverseOriginX = pixels.x / density;\n  const inverseOriginY = pixels.y / density;\n  if (\n    !Number.isFinite(inverseDensity) ||\n    inverseDensity <= 0 ||\n    !Object.values(logicalBounds).every(Number.isFinite) ||\n    !Number.isFinite(inverseOriginX) ||\n    !Number.isFinite(inverseOriginY)\n  ) {\n    return undefined;\n  }\n  const renderTransform = new DOMMatrix([\n    density,\n    0,\n    0,\n    density,\n    -pixels.x,\n    -pixels.y,\n  ]);\n  const inverseRenderTransform = new DOMMatrix([\n    inverseDensity,\n    0,\n    0,\n    inverseDensity,\n    inverseOriginX,\n    inverseOriginY,\n  ]);\n  if (\n    !isFiniteAffine(renderTransform) ||\n    !isFiniteAffine(inverseRenderTransform)\n  ) {\n    return undefined;\n  }\n  return {\n    logicalBounds: Object.freeze(logicalBounds),\n    backingX: pixels.x,\n    backingY: pixels.y,\n    backingWidth: pixels.width,\n    backingHeight: pixels.height,\n    renderTransform,\n    inverseRenderTransform,\n  };\n}\n\nfunction assertPixelEdges(\n  left: number,\n  top: number,\n  right: number,\n  bottom: number,\n): void {\n  const edges = { left, top, right, bottom };\n  if (!Object.values(edges).every(Number.isSafeInteger)) {\n    throw filterRegionError(\n      edges,\n      'filter backing edges must remain finite safe integers',\n    );\n  }\n  const width = right - left;\n  const height = bottom - top;\n  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height)) {\n    throw filterRegionError(\n      { width, height },\n      'filter backing dimensions must remain finite safe integers',\n    );\n  }\n}\n\nfunction assertCanvasPixelBounds(bounds: Readonly<PixelBounds>): void {\n  const { width, height } = bounds;\n  if (\n    !Number.isSafeInteger(width) ||\n    !Number.isSafeInteger(height) ||\n    width <= 0 ||\n    height <= 0 ||\n    width > MAX_UNSIGNED_LONG ||\n    height > MAX_UNSIGNED_LONG\n  ) {\n    throw filterRegionError(\n      { width, height },\n      `filter backing dimensions must be positive unsigned-long integers no greater than ${MAX_UNSIGNED_LONG}`,\n    );\n  }\n  const area = width * height;\n  if (!Number.isSafeInteger(area)) {\n    throw filterRegionError(\n      area,\n      'filter backing area must remain a finite safe integer',\n    );\n  }\n}\n\nfunction isFiniteAffine(matrix: DOMMatrixReadOnly): boolean {\n  return matrix.is2D && [\n    matrix.a,\n    matrix.b,\n    matrix.c,\n    matrix.d,\n    matrix.e,\n    matrix.f,\n  ].every(Number.isFinite);\n}\n\nfunction filterRegionError(value: unknown, reason: string): Error {\n  const type = GLOBAL_STATE.componentRefs?.element.type;\n  const component = typeof type === 'function' && type.name ?\n    type.name : 'filter boundary';\n  return layoutDiagnostic({\n    component,\n    property: 'filter.backingDimensions',\n    value,\n    algorithm: 'filter-capture',\n    reason,\n  });\n}\n"],
+  "mappings": "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",
+  "names": ["ratio", "schurComplement"]
+}