@lifeart/async-dom 2.0.0-alpha.3

package/dist/index.d.cts

@@ -0,0 +1,560 @@
+import { _ as Priority, c as DomMutation, g as NodeId, i as AppId, p as Message, t as Transport, v as SerializedError } from "./base.cjs";
+import { a as MutationLogEntry, l as WarningLogEntry, n as DebugOptions } from "./debug.cjs";
+import { c as WebSocketTransportOptions } from "./worker-transport.cjs";
+
+//#region src/core/html-sanitizer.d.ts
+
+/**
+ * Lightweight HTML sanitizer for async-dom.
+ *
+ * Strips dangerous tags and attributes to prevent XSS when
+ * worker-provided HTML is injected via innerHTML or insertAdjacentHTML.
+ */
+/**
+ * Sanitize an HTML string by removing dangerous tags and attributes.
+ *
+ * Uses the browser's DOMParser to parse the HTML, walks the resulting tree,
+ * and removes any elements/attributes that could execute scripts or load
+ * external resources in a dangerous way.
+ */
+declare function sanitizeHTML(html: string): string;
+//# sourceMappingURL=html-sanitizer.d.ts.map
+//#endregion
+//#region src/core/scheduler.d.ts
+/** Configuration for the FrameScheduler. All fields are optional with sensible defaults. */
+interface SchedulerConfig {
+  /** Maximum milliseconds to spend processing mutations per frame (default: 16ms for 60fps). */
+  frameBudgetMs?: number;
+  /** Whether to skip off-screen style mutations (default: true). */
+  enableViewportCulling?: boolean;
+  /** Whether to drop optional mutations under frame pressure (default: true). */
+  enablePrioritySkipping?: boolean;
+}
+/** Diagnostic record for a single frame, used by devtools flamechart visualization. */
+interface FrameLogEntry {
+  /** Monotonically increasing frame counter. */
+  frameId: number;
+  /** Wall-clock time spent in this frame's tick(), in milliseconds. */
+  totalMs: number;
+  /** Number of mutations applied during this frame. */
+  actionCount: number;
+  /** Cumulative time per mutation action type (e.g., "setAttribute" -> 1.2ms). */
+  timingBreakdown: Map<string, number>;
+  /** Per-app mutation counts and deferred counts per frame (multi-app mode). */
+  perApp?: Map<string, {
+    mutations: number;
+    deferred: number;
+  }>;
+}
+/** Callback that applies a single mutation to the real DOM (typically DomRenderer.apply). */
+type MutationApplier = (mutation: DomMutation, appId: AppId, batchUid?: number) => void;
+/**
+ * Frame-budget scheduler that processes DOM mutations within requestAnimationFrame
+ * callbacks, respecting a configurable time budget per frame.
+ *
+ * Key features preserved from the original vm.js:
+ * - Adaptive batch sizing based on measured action execution times
+ * - Priority sorting (high > normal > low, non-optional before optional)
+ * - Viewport culling for optional style mutations
+ * - Graceful degradation: skip optional mutations under pressure
+ */
+declare class FrameScheduler {
+  /** Priority-sorted queue of pending mutations awaiting application. */
+  private queue;
+  /** Most recent execution time per action type, used for adaptive batch sizing. */
+  private actionTimes;
+  private frameId;
+  private running;
+  private rafId;
+  private uidCounter;
+  private timePerLastFrame;
+  private totalActionsLastFrame;
+  /** True while the user is scrolling; triggers skipping of optional mutations. */
+  private isScrolling;
+  private scrollTimer;
+  private scrollAbort;
+  private viewportHeight;
+  private viewportWidth;
+  /** Cache of element-id -> in-viewport results to avoid repeated getBoundingClientRect. */
+  private boundingRectCache;
+  /** Frame number when each viewport cache entry was last computed. */
+  private boundingRectCacheFrame;
+  private readonly frameBudgetMs;
+  private readonly enableViewportCulling;
+  private readonly enablePrioritySkipping;
+  private applier;
+  /** Number of active apps; enables per-app fairness budget splitting when > 1. */
+  private appCount;
+  /** Per-app mutation count within the current frame, reset each tick. */
+  private appBudgets;
+  private lastTickTime;
+  private healthCheckTimer;
+  private queueOverflowWarned;
+  private lastEnqueueTime;
+  /** Count of frames where processing time exceeded the frame budget. */
+  private droppedFrameCount;
+  private lastWorkerToMainLatencyMs;
+  /** Rolling log of the last MAX_FRAME_LOG frames for devtools inspection. */
+  private frameLog;
+  constructor(config?: SchedulerConfig);
+  /** Set the function that applies each mutation to the real DOM. */
+  setApplier(applier: MutationApplier): void;
+  /** Update the number of active apps for per-app fairness budgeting. */
+  setAppCount(count: number): void;
+  /**
+   * Add mutations to the scheduling queue.
+   * Mutations are not applied immediately; they wait for the next frame tick.
+   * Emits a warning if the queue exceeds 10,000 items (indicates a processing bottleneck).
+   *
+   * @param mutations - Array of DOM mutations to schedule
+   * @param appId - Owning app, used for per-app fairness
+   * @param priority - Scheduling priority (default: "normal")
+   * @param batchUid - Optional batch identifier for grouping
+   */
+  enqueue(mutations: DomMutation[], appId: AppId, priority?: Priority, batchUid?: number): void;
+  /** Start the rAF loop. Sets up scroll detection and a 1-second health check. */
+  start(): void;
+  private scheduleFrame;
+  /** Stop the rAF loop, cancel pending frames, and tear down scroll listeners. */
+  stop(): void;
+  clearViewportCache(): void;
+  /** Synchronously apply all queued mutations, bypassing frame budget. Used for teardown. */
+  flush(): void;
+  /** Number of mutations waiting to be applied. */
+  get pendingCount(): number;
+  /** Record the cross-thread latency from a worker MutationMessage.sentAt */
+  recordWorkerLatency(sentAt: number): void;
+  /** Return a snapshot of scheduler metrics for devtools and diagnostics. */
+  getStats(): {
+    pending: number;
+    frameId: number;
+    lastFrameTimeMs: number;
+    lastFrameActions: number;
+    isRunning: boolean;
+    lastTickTime: number;
+    enqueueToApplyMs: number;
+    droppedFrameCount: number;
+    workerToMainLatencyMs: number;
+  };
+  /** Return a copy of the rolling frame log (last 30 frames). */
+  getFrameLog(): FrameLogEntry[];
+  /**
+   * Core frame loop. Processes as many queued mutations as the frame budget allows.
+   *
+   * Algorithm:
+   * 1. Sort queue by priority (high > normal > low), then optional last, then FIFO
+   * 2. Compute maxActions via getActionsForFrame() (adaptive batch sizing)
+   * 3. Iterate queue, skipping optional mutations under pressure (shouldSkip)
+   * 4. In multi-app mode, enforce per-app fairness caps (maxActions / appCount)
+   * 5. Break if elapsed time exceeds frameBudgetMs (unless queue is critically large)
+   * 6. Re-enqueue deferred items for the next frame
+   */
+  private tick;
+  /** Schedule the next tick, delaying if the frame finished early to avoid busy-spinning. */
+  private scheduleNext;
+  /**
+   * Determine how many mutations to attempt this frame using adaptive batch sizing.
+   *
+   * Strategy (escalating by queue pressure):
+   * - Queue > 25k: emergency flush — process everything in one frame
+   * - Queue >= MAX_QUEUE_BEFORE_FLUSH (3000): process FLUSH_BATCH_SIZE (500)
+   * - Queue > CRITICAL_QUEUE_SIZE (1500): process up to CRITICAL_QUEUE_SIZE
+   * - Otherwise: use the measured average action time to estimate how many
+   *   actions fit in 3x the frame budget (the 3x multiplier allows the time-
+   *   based break in tick() to be the real limiter, while ensuring enough
+   *   work is attempted). Falls back to 2000 when no timing data exists yet.
+   */
+  private getActionsForFrame;
+  /**
+   * Decide whether to skip an optional mutation to preserve frame budget.
+   * Non-optional mutations are never skipped. Optional mutations are skipped when:
+   * - User is actively scrolling (visual updates would be wasted)
+   * - Queue is large (> half of CRITICAL_QUEUE_SIZE), indicating backpressure
+   * - Previous frame exceeded budget (prevent cascading frame drops)
+   */
+  private shouldSkip;
+  /** Record the execution time for an action type. The 0.02ms bias prevents zero-time entries from skewing averages. */
+  private recordTiming;
+  private getAvgActionTime;
+  private calcViewportSize;
+  /**
+   * Check if an element is within the viewport, using a per-frame cache to
+   * avoid repeated getBoundingClientRect calls. Cache entries expire after
+   * VIEWPORT_CACHE_FRAMES (60) frames.
+   */
+  isInViewport(elem: Element): boolean;
+  private setupScrollListener;
+}
+//# sourceMappingURL=scheduler.d.ts.map
+//#endregion
+//#region src/core/node-cache.d.ts
+/**
+ * Cache for mapping NodeIds to real DOM nodes on the main thread.
+ * Supports both forward (NodeId → Node) and reverse (Node → NodeId) lookups.
+ */
+declare class NodeCache {
+  private cache;
+  private reverseCache;
+  get(id: NodeId): Node | null;
+  /** Reverse lookup: get the NodeId for a real DOM node. */
+  getId(node: Node): NodeId | null;
+  set(id: NodeId, node: Node): void;
+  delete(id: NodeId): void;
+  clear(): void;
+  has(id: NodeId): boolean;
+}
+//# sourceMappingURL=node-cache.d.ts.map
+//#endregion
+//#region src/main-thread/event-bridge.d.ts
+/**
+ * Trace record for a single DOM event round-trip, tracking:
+ * - serializeMs: time to serialize the DOM event on the main thread
+ * - transportMs: estimated message transit time (main -> worker -> main)
+ * - dispatchMs: time the worker spent dispatching the event to handlers
+ * - mutationCount: number of mutations the event handler produced
+ */
+interface EventTraceEntry {
+  eventType: string;
+  listenerId: string;
+  /** Time spent serializing the DOM event to a plain object. */
+  serializeMs: number;
+  /** performance.now() when the trace was created. */
+  timestamp: number;
+  /** Date.now() when the event was sent, used to compute transportMs on response. */
+  sentAt: number;
+  /** Estimated round-trip transport time excluding worker dispatch time. */
+  transportMs?: number;
+  /** Time the worker spent in event handler dispatch. */
+  dispatchMs?: number;
+  /** Number of mutations generated by the event handler. */
+  mutationCount?: number;
+}
+/**
+ * Bridges real DOM events on the main thread to the worker thread.
+ * Uses AbortController for clean listener removal.
+ */
+declare class EventBridge {
+  /** Map of listenerId -> AbortController, used for clean listener removal. */
+  private listeners;
+  /** Per-event configuration (e.g., preventDefault) keyed by "{nodeId}_{eventName}". */
+  private eventConfig;
+  private nodeCache;
+  private transport;
+  private appId;
+  /** Rolling buffer of the last MAX_EVENT_TRACES event traces for diagnostics. */
+  private eventTraces;
+  private _onTimingResult;
+  constructor(appId: AppId, nodeCache?: NodeCache);
+  /**
+   * Set a callback that is invoked whenever a trace entry is fully
+   * populated with worker timing data.  This allows callers (e.g. the
+   * devtools debug hooks) to emit EventLogEntry objects.
+   */
+  set onTimingResult(cb: ((trace: EventTraceEntry) => void) | null);
+  setTransport(transport: Transport): void;
+  setNodeCache(nodeCache: NodeCache): void;
+  /**
+   * Configure event behavior for a specific node/event pair.
+   * If preventDefault is set on a normally-passive event (e.g., touchstart),
+   * the listener is detached and re-attached as non-passive so preventDefault works.
+   */
+  configureEvent(nodeId: NodeId, eventName: string, config: {
+    preventDefault: boolean;
+    passive?: boolean;
+  }): void;
+  /**
+   * Attach a real DOM event listener that serializes the event and sends it to the worker.
+   * Uses AbortController for deterministic cleanup. Idempotent: re-attaching the same
+   * listenerId aborts the previous listener first.
+   */
+  attach(nodeId: NodeId, eventName: string, listenerId: string): void;
+  /** Remove a single listener by its ID, aborting the AbortController. */
+  detach(listenerId: string): void;
+  /** Remove all listeners attached to a specific node (called when a node is removed). */
+  detachByNodeId(nodeId: NodeId): void;
+  getEventTraces(): EventTraceEntry[];
+  /**
+   * Update the most recent trace entry for a given listener with
+   * dispatch and mutation count timing from the worker.
+   * Transport time is computed on the main thread to avoid cross-origin
+   * timing issues between main thread and worker `performance.now()`.
+   */
+  updateTraceWithWorkerTiming(listenerId: string, dispatchMs: number, mutationCount: number): void;
+  getListenersForNode(nodeId: NodeId): Array<{
+    listenerId: string;
+    eventName: string;
+  }>;
+  /** Remove all listeners across all nodes. Called during teardown. */
+  detachAll(): void;
+  private _isPassiveForListener;
+}
+//# sourceMappingURL=event-bridge.d.ts.map
+//#endregion
+//#region src/main-thread/renderer.d.ts
+/**
+ * Security permissions controlling which mutation types the renderer will execute.
+ * Defaults are restrictive; enable only what the app needs.
+ */
+interface RendererPermissions {
+  /** Allow appending nodes directly to <head> (e.g., for injecting styles). */
+  allowHeadAppend: boolean;
+  /** Allow appending nodes directly to <body>. */
+  allowBodyAppend: boolean;
+  /** Allow history.pushState/replaceState calls. */
+  allowNavigation: boolean;
+  /** Allow window.scrollTo calls. */
+  allowScroll: boolean;
+  /** Bypass HTML sanitization for innerHTML/insertAdjacentHTML. */
+  allowUnsafeHTML: boolean;
+  /** Additional DOM property names allowed for setProperty beyond the built-in list. */
+  additionalAllowedProperties?: string[];
+}
+/**
+ * Root elements for the renderer's DOM mount point.
+ * Defaults to document.body/head/documentElement but can be overridden
+ * to render into a shadow DOM or iframe.
+ */
+interface RendererRoot {
+  /** The element or shadow root that serves as the `<body>` equivalent. */
+  body: Element | ShadowRoot;
+  /** The element or shadow root that serves as the `<head>` equivalent. */
+  head: Element | ShadowRoot;
+  /** The element that serves as the `<html>` equivalent. */
+  html: Element;
+}
+/**
+ * Configuration for automatic content-visibility: auto on top-level children
+ * of the mount point, enabling the browser to skip rendering off-screen subtrees.
+ */
+interface ContentVisibilityConfig {
+  /** Whether the optimization is active. */
+  enabled: boolean;
+  /** CSS `contain-intrinsic-size` value applied to container elements (e.g. `"auto 500px"`). */
+  intrinsicSize: string;
+}
+/**
+ * Applies DOM mutations from the worker thread to the real browser DOM.
+ *
+ * Maintains a NodeCache mapping worker-side NodeIds to real DOM Node references.
+ * Each mutation type is dispatched through the apply() method, which acts as
+ * the single entry point for the scheduler.
+ *
+ * Security: blocks on* attribute handlers, javascript: URIs, and restricts
+ * which DOM properties can be set via an allowlist.
+ */
+declare class DomRenderer {
+  /** Maps NodeId -> real DOM Node for O(1) lookup during mutation application. */
+  private nodeCache;
+  private permissions;
+  private root;
+  private _additionalAllowedProperties;
+  /** Callback invoked when a node is removed, allowing EventBridge to detach listeners. */
+  onNodeRemoved: ((id: NodeId) => void) | null;
+  private _onWarning;
+  private _onMutation;
+  private highlightEnabled;
+  private _contentVisibility;
+  setDebugHooks(hooks: {
+    onWarning?: ((e: WarningLogEntry) => void) | null;
+    onMutation?: ((e: MutationLogEntry) => void) | null;
+  }): void;
+  enableHighlightUpdates(enabled: boolean): void;
+  setContentVisibility(config: ContentVisibilityConfig | null): void;
+  private highlightNode;
+  constructor(nodeCache?: NodeCache, permissions?: Partial<RendererPermissions>, root?: RendererRoot);
+  /**
+   * Apply a single DOM mutation to the real DOM.
+   * This is the main entry point called by the FrameScheduler's applier callback.
+   * Event-related mutations (addEventListener, configureEvent, removeEventListener)
+   * are no-ops here as they are handled by EventBridge.
+   *
+   * @param mutation - The mutation to apply
+   * @param batchUid - Optional batch identifier for debug logging
+   */
+  apply(mutation: DomMutation, batchUid?: number): void;
+  /** Look up the real DOM node for a given NodeId, or null if not cached. */
+  getNode(id: NodeId): Node | null;
+  clear(): void;
+  /**
+   * Clear the node cache but preserve structural nodes (BODY, HEAD, HTML, DOCUMENT).
+   * Used during replay to allow re-creation of dynamic nodes while keeping the
+   * root structure intact.
+   */
+  resetNodeCache(): void;
+  getRoot(): RendererRoot;
+  /**
+   * Create a DOM element or text node and store it in the node cache.
+   * Structural tags (HTML, BODY, HEAD) are mapped to existing DOM elements rather than created.
+   * Tags starting with "#" are treated as text nodes.
+   * SVG tags are created with the SVG namespace.
+   */
+  private createNode;
+  private createComment;
+  private appendChild;
+  private removeNode;
+  private removeChild;
+  private insertBefore;
+  private setAttribute;
+  private removeAttribute;
+  private setStyle;
+  private setProperty;
+  private setTextContent;
+  private setClassName;
+  private setHTML;
+  private insertAdjacentHTML;
+  private headAppendChild;
+  private bodyAppendChild;
+  /**
+   * Call a whitelisted method on a DOM node (e.g., focus, play, showModal).
+   * Methods not in ALLOWED_METHODS are silently blocked.
+   */
+  private callMethod;
+  /** Inline element tags that should not receive content-visibility. */
+  private static readonly INLINE_TAGS;
+  /**
+   * Apply content-visibility: auto to top-level children of the mount point.
+   * Only applies to block-level HTMLElements that don't already have it set.
+   */
+  private _applyContentVisibility;
+  /**
+   * Notify onNodeRemoved for a node and all its descendants.
+   * This ensures EventBridge detaches listeners on the entire subtree.
+   */
+  private _cleanupSubtreeListeners;
+}
+//# sourceMappingURL=renderer.d.ts.map
+//#endregion
+//#region src/main-thread/thread-manager.d.ts
+interface WorkerConfig {
+  worker: Worker;
+  transport?: Transport;
+  /** Human-readable name for this app (shown in DevTools instead of a random hash) */
+  name?: string;
+}
+interface RemoteConfig {
+  transport: Transport;
+  name?: string;
+}
+interface WebSocketConfig {
+  url: string;
+  options?: WebSocketTransportOptions;
+  /** Human-readable name for this app (shown in DevTools instead of a random hash) */
+  name?: string;
+}
+/**
+ * Manages multiple worker/WebSocket connections, routing messages
+ * between the main thread and isolated app threads.
+ */
+declare class ThreadManager {
+  private threads;
+  private messageHandlers;
+  createWorkerThread(config: WorkerConfig): AppId;
+  createRemoteThread(config: RemoteConfig): AppId;
+  createWebSocketThread(config: WebSocketConfig): AppId;
+  sendToThread(appId: AppId, message: Message): void;
+  broadcast(message: Message): void;
+  destroyThread(appId: AppId): void;
+  destroyAll(): void;
+  onMessage(handler: (appId: AppId, message: Message) => void): void;
+  getTransport(appId: AppId): Transport | null;
+  private notifyHandlers;
+  /** Generate a unique AppId, appending a suffix if the name already exists. */
+  private _uniqueAppId;
+}
+//# sourceMappingURL=thread-manager.d.ts.map
+//#endregion
+//#region src/main-thread/index.d.ts
+/**
+ * Configuration for {@link createAsyncDom}.
+ *
+ * At minimum, provide a `target` element where worker-rendered DOM will be mounted.
+ * Optionally pass a `worker` to immediately register the first app.
+ */
+interface AsyncDomConfig {
+  /** The DOM element that serves as the rendering root for worker-produced mutations. */
+  target: Element;
+  /** Optional initial worker. If provided, it is registered as the first app automatically. */
+  worker?: Worker;
+  /** Frame-budget scheduler tuning options. */
+  scheduler?: SchedulerConfig;
+  /** Debug logging and devtools panel options. */
+  debug?: DebugOptions;
+  /**
+   * Enable `content-visibility: auto` on top-level container elements for off-screen
+   * rendering optimization. Pass `true` for defaults, or an object with a custom
+   * `intrinsicSize` (CSS value, default `"auto 500px"`).
+   */
+  contentVisibility?: boolean | {
+    intrinsicSize?: string;
+  };
+}
+/**
+ * Configuration for adding a worker-backed app via {@link AsyncDomInstance.addApp}.
+ */
+interface AppConfig {
+  /** The Web Worker instance that runs this app's UI logic. */
+  worker: Worker;
+  /** Human-readable name for this app (shown in DevTools instead of a random hash). */
+  name?: string;
+  /** CSS selector or Element where this app's DOM will be mounted. Defaults to the instance root. */
+  mountPoint?: string | Element;
+  /** Attach to a Shadow DOM root for CSS isolation. Pass `true` for `{ mode: "open" }` or a custom `ShadowRootInit`. */
+  shadow?: boolean | ShadowRootInit;
+  /** Custom transport to use instead of the default `WorkerTransport`. */
+  transport?: Transport;
+  /** Called when the worker reports an unhandled error or unhandled promise rejection. */
+  onError?: (error: SerializedError, appId: AppId) => void;
+}
+/**
+ * Configuration for adding a remote (non-worker) app via {@link AsyncDomInstance.addRemoteApp}.
+ *
+ * Remote apps communicate over a custom transport (e.g. WebSocket) rather than
+ * a local Web Worker.
+ */
+interface RemoteAppConfig {
+  /** The transport used to communicate with the remote process. */
+  transport: Transport;
+  /** Human-readable name for this app (shown in DevTools instead of a random hash). */
+  name?: string;
+  /** CSS selector or Element where this app's DOM will be mounted. Defaults to the instance root. */
+  mountPoint?: string | Element;
+  /** Attach to a Shadow DOM root for CSS isolation. Pass `true` for `{ mode: "open" }` or a custom `ShadowRootInit`. */
+  shadow?: boolean | ShadowRootInit;
+  /** Called when the remote process reports an unhandled error. */
+  onError?: (error: SerializedError, appId: AppId) => void;
+  /** Enable `SharedArrayBuffer`-based sync channel for synchronous DOM reads. Default: `false`. */
+  enableSyncChannel?: boolean;
+}
+/**
+ * Handle returned by {@link createAsyncDom}.
+ *
+ * Controls the lifecycle of the async-dom instance: starting/stopping the
+ * scheduler, adding/removing apps, and tearing down all resources.
+ */
+interface AsyncDomInstance {
+  /** Start the frame-budget scheduler. Mutations begin applying to the DOM. */
+  start(): void;
+  /** Pause the scheduler. Mutations are queued but not applied until `start()` is called. */
+  stop(): void;
+  /** Stop the scheduler, flush remaining mutations, tear down all apps, and release all resources. */
+  destroy(): void;
+  /** Register a new worker-backed app. Returns a unique `AppId` for later removal. */
+  addApp(config: AppConfig): AppId;
+  /** Register a new remote app using a custom transport. Returns a unique `AppId` for later removal. */
+  addRemoteApp(config: RemoteAppConfig): AppId;
+  /** Remove an app by its `AppId`, detaching its event listeners and clearing its rendered DOM. */
+  removeApp(appId: AppId): void;
+}
+/**
+ * Creates a new async-dom instance on the main thread.
+ *
+ * This is the primary entry point for using async-dom. It:
+ * - Creates a scheduler for frame-budgeted rendering
+ * - Creates per-app renderers for applying DOM mutations (isolation)
+ * - Creates an event bridge for forwarding events to workers
+ * - Manages worker threads
+ */
+declare function createAsyncDom(config: AsyncDomConfig): AsyncDomInstance;
+//#endregion
+export { sanitizeHTML as _, createAsyncDom as a, WebSocketConfig as c, DomRenderer as d, RendererPermissions as f, SchedulerConfig as g, FrameScheduler as h, RemoteAppConfig as i, WorkerConfig as l, EventBridge as m, AsyncDomConfig as n, RemoteConfig as o, RendererRoot as p, AsyncDomInstance as r, ThreadManager as s, AppConfig as t, ContentVisibilityConfig as u };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/core/html-sanitizer.ts","../src/core/scheduler.ts","../src/core/node-cache.ts","../src/main-thread/event-bridge.ts","../src/main-thread/renderer.ts","../src/main-thread/thread-manager.ts","../src/main-thread/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AA4CA;;;;AClCA;AAUA;;;AAUU,iBDcM,YAAA,CCdN,IAAA,EAAA,MAAA,CAAA,EAAA,MAAA;;;;;UApBO,eAAA;;;EDkCD;;;;AClChB;AAUA;AAA8B,UAAb,aAAA,CAAa;;SAUpB,EAAA,MAAA;EAAG;EAiBD,OAAA,EAAA,MAAA;EAAe;aAAc,EAAA,MAAA;;EAAyB,eAAA,EAnBhD,GAmBgD,CAAA,MAAA,EAAA,MAAA,CAAA;EAYrD;EAAc,MAAA,CAAA,EA7BjB,GA6BiB,CAAA,MAAA,EAAA;IAiDN,SAAA,EAAA,MAAA;IAOA,QAAA,EAAA,MAAA;;;;AAqJL,KAzNJ,eAAA,GAyNI,CAAA,QAAA,EAzNyB,WAyNzB,EAAA,KAAA,EAzN6C,KAyN7C,EAAA,QAAA,CAAA,EAAA,MAAA,EAAA,GAAA,IAAA;;;;;;ACjQhB;;;;;AAWoB,cDyCP,cAAA,CCzCO;;UAIG,KAAA;;UAkBd,WAAA;EAAM,QAAA,OAAA;;;;EC7BE,QAAA,gBAAe;EAuBnB,QAAA,qBAAW;EAAA;UAeJ,WAAA;UAAmB,WAAA;UAUN,WAAA;UAIR,cAAA;UAIA,aAAA;;UAmCT,iBAAA;;UAmEG,sBAAA;mBAyBU,aAAA;mBAAS,qBAAA;EAAK,iBAAA,sBAAA;;;;EC3K1B;EAwHA,QAAA,UAAY;EAAA,QAAA,YAAA;UAEtB,gBAAA;UAAU,mBAAA;UAEV,eAAA;;UAEA,iBAAA;EAAO,QAAA,yBAAA;EAOG;EAiBJ,QAAA,QAAW;EAAA,WAAA,CAAA,MAAA,CAAA,EHjEH,eGiEG;;YAcL,CAAA,OAAA,EHxEE,eGwEF,CAAA,EAAA,IAAA;;aAWW,CAAA,KAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;;;;;;;;;;qBH/DjB,sBACJ,kBACG;;EIlIK,KAAA,CAAA,CAAA,EAAA,IAAA;EAAY,QAAA,aAAA;;MAEhB,CAAA,CAAA,EAAA,IAAA;EAAS,kBAAA,CAAA,CAAA,EAAA,IAAA;EAKL;EAKA,KAAA,CAAA,CAAA,EAAA,IAAA;EAgBJ;EAAa,IAAA,YAAA,CAAA,CAAA,EAAA,MAAA;;qBAIiB,CAAA,MAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;UAeA,CAAA,CAAA,EAAA;IAYZ,OAAA,EAAA,MAAA;IAAkB,OAAA,EAAA,MAAA;IAY5B,eAAA,EAAA,MAAA;IAAgB,gBAAA,EAAA,MAAA;IAOjB,SAAA,EAAA,OAAA;IAME,YAAA,EAAA,MAAA;IAcM,gBAAA,EAAA,MAAA;IAAgB,iBAAA,EAAA,MAAA;IAIvB,qBAAA,EAAA,MAAA;;EAAiB;iBJ2JtB;;;AKnMhB;;;;;;;AAoBA;;UAES,IAAA;;UAMW,YAAA;;;;;AAapB;;;;;;;;EAqBiB,QAAA,kBAAgB;EAAA;;;;;;;EAwBjB,QAAA,UAAc;EAAA;UAAS,YAAA;UAAiB,gBAAA;EAAgB,QAAA,gBAAA;;;;;;qBLiWpD;;;;;;;;;;ADhdJ,cErCH,SAAA,CFqCe;;;UEjCnB,SAAS;EDDD;EAUA,KAAA,CAAA,IAAA,ECFJ,IDEiB,CAAA,ECFV,MDEU,GAAA,IAAA;EAAA,GAAA,CAAA,EAAA,ECErB,MDFqB,EAAA,IAAA,ECEP,IDFO,CAAA,EAAA,IAAA;QAQZ,CAAA,EAAA,ECDN,MDCM,CAAA,EAAA,IAAA;OAER,CAAA,CAAA,EAAA,IAAA;EAAG,GAAA,CAAA,EAAA,ECUJ,MDVI,CAAA,EAAA,OAAA;AAiBb;;;;;;ADHA;;;;AClCA;AAUiB,UETA,eAAA,CFSa;EAAA,SAAA,EAAA,MAAA;YAQZ,EAAA,MAAA;;EAEL,WAAA,EAAA,MAAA;EAiBD;EAAe,SAAA,EAAA,MAAA;;QAAkC,EAAA,MAAA;EAAK;EAYrD,WAAA,CAAA,EAAA,MAAc;EAAA;YAiDN,CAAA,EAAA,MAAA;;eA2BR,CAAA,EAAA,MAAA;;;;;;cErGA,WAAA;;;ED3BA;EAAS,QAAA,WAAA;UAIb,SAAA;UAAS,SAAA;UAOL,KAAA;;UAIJ,WAAA;UAAc,eAAA;aAKX,CAAA,KAAA,ECsBQ,KDtBR,EAAA,SAAA,CAAA,ECsB2B,SDtB3B;;;;;;EChBK,IAAA,cAAe,CAAA,EAAA,EAAA,CAAA,CAAA,KAAA,EAgDC,eAhDD,EAAA,GAAA,IAAA,CAAA,GAAA,IAAA;EAuBnB,YAAA,CAAA,SAAW,EA6BC,SA7BD,CAAA,EAAA,IAAA;EAAA,YAAA,CAAA,SAAA,EAiCC,SAjCD,CAAA,EAAA,IAAA;;;;;;gBA2Cd,CAAA,MAAA,EAAA,MAAA,EAAA,SAAA,EAAA,MAAA,EAAA,MAAA,EAAA;IAyBM,cAAA,EAAA,OAAA;IA0DQ,OAAA,CAAA,EAAA,OAAA;MASL,IAAA;;;;;;iBAnEH;EC/EC;EAwHA,MAAA,CAAA,UAAY,EAAA,MAAA,CAAA,EAAA,IAAA;EAAA;gBAEtB,CAAA,MAAA,EDeiB,MCfjB,CAAA,EAAA,IAAA;gBAAU,CAAA,CAAA,EDwBE,eCxBF,EAAA;;;;;AAWjB;AAiBA;EAAwB,2BAAA,CAAA,UAAA,EAAA,MAAA,EAAA,UAAA,EAAA,MAAA,EAAA,aAAA,EAAA,MAAA,CAAA,EAAA,IAAA;qBAOF,CAAA,MAAA,EDcO,MCdP,CAAA,EDcgB,KCdhB,CAAA;IAOH,UAAA,EAAA,MAAA;IACC,SAAA,EAAA,MAAA;;;WA2BI,CAAA,CAAA,EAAA,IAAA;UAAR,qBAAA;;;;;;;AJ3KhB;;UIrBiB,mBAAA;;EHbA,eAAA,EAAA,OAAe;EAUf;EAAa,eAAA,EAAA,OAAA;;iBAUpB,EAAA,OAAA;EAAG;EAiBD,WAAA,EAAA,OAAe;EAAA;iBAAc,EAAA,OAAA;;EAAyB,2BAAA,CAAA,EAAA,MAAA,EAAA;AAYlE;;;;;;AA8EY,UGMK,YAAA,CHNL;;MAmXQ,EG3Wb,OH2Wa,GG3WH,UH2WG;EAAO;QGzWpB,UAAU;;QAEV;AF9IP;;;;;AAWoB,UE0IH,uBAAA,CF1IG;;SAIG,EAAA,OAAA;;eAkBd,EAAA,MAAA;;;;;AC7BT;AAuBA;;;;;;AAiCyB,cC0GZ,WAAA,CD1GY;;UAmCT,SAAA;UA0DQ,WAAA;UASL,IAAA;UAyBU,4BAAA;;EAAc,aAAA,EAAA,CAAA,CAAA,EAAA,ECdrB,MDcqB,EAAA,GAAA,IAAA,CAAA,GAAA,IAAA;;;;EC3K1B,QAAA,kBAAmB;EAwHnB,aAAA,CAAA,KAAY,EAAA;IAAA,SAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EA4CV,eA5CU,EAAA,GAAA,IAAA,CAAA,GAAA,IAAA;IAEtB,UAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EA2Ca,gBA3Cb,EAAA,GAAA,IAAA,CAAA,GAAA,IAAA;MAAU,IAAA;wBAEV,CAAA,OAAA,EAAA,OAAA,CAAA,EAAA,IAAA;sBAAU,CAAA,MAAA,EAmDa,uBAnDb,GAAA,IAAA,CAAA,EAAA,IAAA;UAEV,aAAA;EAAO,WAAA,CAAA,SAAA,CAAA,EAiEA,SAjEA,EAAA,WAAA,CAAA,EAkEE,OAlEF,CAkEU,mBAlEV,CAAA,EAAA,IAAA,CAAA,EAmEL,YAnEK;EAOG;AAiBjB;;;;;;;;OA0CgB,CAAA,QAAA,EAsBC,WAtBD,EAAA,QAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;SAsBC,CAAA,EAAA,EAyGJ,MAzGI,CAAA,EAyGK,IAzGL,GAAA,IAAA;OAyGJ,CAAA,CAAA,EAAA,IAAA;;;;;;;EC/UI,OAAA,CAAA,CAAA,EDqWL,YCrWiB;EAAA;;;;AAO7B;AAKA;EAgBa,QAAA,UAAa;EAAA,QAAA,aAAA;UAIE,WAAA;UAAe,UAAA;UAef,WAAA;UAAe,YAAA;UAYZ,YAAA;UAAkB,eAAA;UAY5B,QAAA;UAAgB,WAAA;UAOjB,cAAA;UAME,YAAA;UAcM,OAAA;UAAgB,kBAAA;UAIvB,eAAA;UAAQ,eAAA;EAAS;;;;ECxCrB,QAAA,UAAc;EAAA;0BAEtB,WAAA;;;;;EAkBQ,QAAA,uBAAS;EAAA;;;;UAQQ,wBAAA;;;;;UD1FjB,YAAA;UACR;ELoCO,SAAA,CAAA,EKnCH,SLmCe;;;;AClCX,UIIA,YAAA,CJJe;EAUf,SAAA,EILL,SJKkB;EAAA,IAAA,CAAA,EAAA,MAAA;;AAUpB,UIXO,eAAA,CJWP;EAAG,GAAA,EAAA,MAAA;EAiBD,OAAA,CAAA,EI1BD,yBJ0BgB;EAAA;MAAc,CAAA,EAAA,MAAA;;;AAYzC;;;AAwDqB,cIhFR,aAAA,CJgFQ;UAoBR,OAAA;UACJ,eAAA;oBACG,CAAA,MAAA,EIlGgB,YJkGhB,CAAA,EIlG+B,KJkG/B;oBA+HI,CAAA,MAAA,EIlNY,YJkNZ,CAAA,EIlN2B,KJkN3B;uBAoPI,CAAA,MAAA,EI1bW,eJ0bX,CAAA,EI1b6B,KJ0b7B;EAAO,YAAA,CAAA,KAAA,EI9aN,KJ8aM,EAAA,OAAA,EI9aU,OJ8aV,CAAA,EAAA,IAAA;qBIvaP;uBAME;;EHpFT,SAAA,CAAA,OAAS,EAAA,CAAA,KAAA,EGkGM,KHlGN,EAAA,OAAA,EGkGsB,OHlGtB,EAAA,GAAA,IAAA,CAAA,EAAA,IAAA;EAAA,YAAA,CAAA,KAAA,EGsGD,KHtGC,CAAA,EGsGO,SHtGP,GAAA,IAAA;UAIb,cAAA;;UAOI,YAAA;;;;;;;AF0Bb;;;;AClCiB,UK2DA,cAAA,CL3De;EAUf;EAAa,MAAA,EKmDrB,OLnDqB;;QAUpB,CAAA,EK2CA,ML3CA;EAAG;EAiBD,SAAA,CAAA,EK4BC,eL5Bc;EAAA;OAAc,CAAA,EK8BhC,YL9BgC;;;AAYzC;;;mBAwDqB,CAAA,EAAA,OAAA,GAAA;IAoBR,aAAA,CAAA,EAAA,MAAA;;;;;;UK9CI,SAAA;;UAER;EJpFI;EAAS,IAAA,CAAA,EAAA,MAAA;;YAIJ,CAAA,EAAA,MAAA,GIoFK,OJpFL;;QAOE,CAAA,EAAA,OAAA,GI+EA,cJ/EA;;WAIG,CAAA,EI2EW,SJ3EX;;SAkBd,CAAA,EAAA,CAAA,KAAA,EI2D4C,eJ3D5C,EAAA,KAAA,EI6DgE,KJ7DhE,EAAA,GAAA,IAAA;;;;;AC7BT;AAuBA;;AAeoB,UG6DH,eAAA,CH7DG;;WAUa,EGmDD,SHnDC;;MAQR,CAAA,EAAA,MAAA;;YAmCT,CAAA,EAAA,MAAA,GGcO,OHdP;;QAmEG,CAAA,EAAA,OAAA,GGnDC,cHmDD;;SAyBmB,CAAA,EAAA,CAAA,KAAA,EG5EJ,eH4EI,EAAA,KAAA,EG1EmC,KH0EnC,EAAA,GAAA,IAAA;EAAK;;;;AC3K3C;AAwHA;;;;AAIO,UEhBU,gBAAA,CFgBV;;OAEA,EAAA,EAAA,IAAA;EAAO;EAOG,IAAA,EAAA,EAAA,IAAA;EAiBJ;EAAW,OAAA,EAAA,EAAA,IAAA;;QAcL,CAAA,MAAA,EEhDH,SFgDG,CAAA,EEhDS,KFgDT;;cAWW,CAAA,MAAA,EEzDR,eFyDQ,CAAA,EEzDU,KFyDV;;WAiBN,CAAA,KAAA,EExEN,KFwEM,CAAA,EAAA,IAAA;;;;;;;;;;;AChNP,iBCoJD,cAAA,CDpJa,MAAA,ECoJU,cDpJV,CAAA,ECoJ2B,gBDpJ3B"}