@heartlandone/vega 2.95.0 → 2.96.0

package/dist/collection/helpers/a11y-tree/strategies/webkit-voiceover-strategy.js

@@ -0,0 +1,140 @@
+import { baselineStrategy } from './baseline-strategy';
+/**
+ * WebKit + VoiceOver strategy.
+ *
+ * Applies on top of the baseline to work around two known VoiceOver quirks:
+ *
+ * **Quirk #1 — `aria-describedby` on non-focusable containers is skipped.**
+ * VoiceOver on Safari often does not read `aria-describedby` on non-focusable
+ * `role="group"` (A11yContainerNode) or `role="region"` (A11yLandmarkNode)
+ * containers. Workaround: fold the description text directly into the
+ * heading's `aria-label` (joined with `. `) so it is read together with the
+ * title, and remove the orphaned `aria-describedby` patch.
+ *
+ * **Quirk #2 — Decorative `<vega-icon>` announced twice.**
+ * Safari occasionally announces a decorative icon twice when only
+ * `aria-hidden` is set on the host. We additionally set `role="none"` as a
+ * belt-and-suspenders guard that suppresses the extra announcement.
+ *
+ * These adjustments are applied as a *diff* on top of the baseline patch
+ * list — the A11y Tree itself is unchanged. Other node types fall back to
+ * baseline behaviour.
+ */
+export const webkitVoiceOverStrategy = {
+  name: 'webkit-voiceover',
+  /**
+   * Compile ARIA patches, applying the two VoiceOver workarounds.
+   *
+   * @param {A11yNode} root - Root of the semantic A11y Tree to compile.
+   * @returns {AriaPatch[]} ARIA patches adjusted for WebKit + VoiceOver.
+   */
+  compile(root) {
+    var _a;
+    const patches = baselineStrategy.compile(root);
+    // Quirk #1: fold each described container's description into its heading's
+    // aria-label. The non-focusable-container quirk affects both role="group"
+    // (A11yContainerNode) and role="region" (A11yLandmarkNode). Generalized to
+    // iterate every described container so components with multiple described
+    // groups/regions all get folded correctly instead of only the first pair.
+    for (const container of collectDescribedContainers(root)) {
+      // Use the first heading owned by this container (not crossing nested
+      // described-container boundaries), or fall back to the container itself.
+      const heading = (_a = findOwnedHeading(container)) !== null && _a !== void 0 ? _a : container;
+      const combined = [heading.label, container.description].filter(Boolean).join('. ');
+      // Emit an explicit removal patch (value: null) for the container's
+      // aria-describedby. VoiceOver double-announces the description when it
+      // is both folded into the heading label AND referenced via
+      // aria-describedby, so we untrack the attribute declaratively (rather
+      // than silently dropping the patch) to keep re-render cleanup correct.
+      //
+      // When folding onto the container itself (no owned heading found), also
+      // update the existing aria-label patch in-place so we do not produce a
+      // duplicate patch that would leave the old value visible to consumers
+      // using Array.find().
+      const foldingOntoContainer = heading.id === container.id;
+      for (const p of patches) {
+        if (p.targetId === container.id && p.attribute === 'aria-describedby') {
+          p.value = null;
+        }
+        if (foldingOntoContainer && p.targetId === container.id && p.attribute === 'aria-label') {
+          p.value = combined;
+        }
+      }
+      if (!foldingOntoContainer) {
+        patches.push({ targetId: heading.id, attribute: 'aria-label', value: combined });
+      }
+    }
+    // Quirk #2: harden decorative icons with role="none".
+    walkIcons(root, (n) => {
+      if (n.decorative) {
+        patches.push({ targetId: n.id, attribute: 'role', value: 'none' });
+      }
+    });
+    return patches;
+  },
+};
+/**
+ * Find the first heading node owned directly by a described container,
+ * stopping at nested described-container boundaries.
+ *
+ * A heading "owned" by a container is one that lives in that container's
+ * direct subtree but NOT inside a nested described group/region. Those inner
+ * headings belong to the inner container's own fold pass, so crossing their
+ * boundary would cause the outer container's description to overwrite the
+ * inner heading's aria-label and then be lost when the inner pass runs.
+ *
+ * If no owned heading is found, the caller falls back to the container itself
+ * (the `?? container` in compile()), folding the description onto the
+ * container's own aria-label.
+ *
+ * @param {A11yNode} node - The container to search within.
+ * @returns {A11yNode | undefined} First heading owned by this container, if any.
+ */
+function findOwnedHeading(node) {
+  var _a;
+  for (const c of (_a = node.children) !== null && _a !== void 0 ? _a : []) {
+    // Stop at nested described-container boundaries — their headings belong
+    // to those containers' own fold passes, not this one.
+    if ((c.role === 'group' || c.role === 'region') && c.description) {
+      continue;
+    }
+    if (c.role === 'heading')
+      return c;
+    const hit = findOwnedHeading(c);
+    if (hit)
+      return hit;
+  }
+  return undefined;
+}
+/**
+ * Visit every image node in the tree, invoking the callback on each.
+ *
+ * @param {A11yNode} node - Node to walk from.
+ * @param {(n: A11yNode) => void} fn - Callback invoked for each image node.
+ */
+function walkIcons(node, fn) {
+  var _a;
+  if (node.role === 'img')
+    fn(node);
+  (_a = node.children) === null || _a === void 0 ? void 0 : _a.forEach((c) => walkIcons(c, fn));
+}
+/**
+ * Collect every `group` or `region` node in the tree that carries a
+ * description, in depth-first order. Includes nested described containers.
+ *
+ * @param {A11yNode} node - Node to search from.
+ * @returns {A11yNode[]} All described container nodes, including nested ones.
+ */
+function collectDescribedContainers(node) {
+  var _a;
+  const out = [];
+  // Check if this node is a described container
+  if ((node.role === 'group' || node.role === 'region') && node.description) {
+    out.push(node);
+  }
+  // Always recurse into children to find nested described containers
+  for (const c of (_a = node.children) !== null && _a !== void 0 ? _a : []) {
+    out.push(...collectDescribedContainers(c));
+  }
+  return out;
+}

package/dist/collection/helpers/a11y-tree/strategy-resolver.js

@@ -0,0 +1,172 @@
+import { baselineStrategy } from './strategies/baseline-strategy';
+import { firefoxNvdaStrategy } from './strategies/firefox-nvda-strategy';
+import { webkitVoiceOverStrategy } from './strategies/webkit-voiceover-strategy';
+/**
+ * All registered strategies. The resolver picks from this list; callers that
+ * need exhaustive enumeration (e.g. tests, Storybook knobs) can import this
+ * constant directly.
+ */
+export const ALL_A11Y_STRATEGIES = [
+  baselineStrategy,
+  webkitVoiceOverStrategy,
+  firefoxNvdaStrategy,
+];
+/**
+ * Picks an `A11yTreeStrategy` from the runtime environment and returns the
+ * full `A11yStrategyResolution` including confidence and a reason string.
+ *
+ * ## Browser-engine detection
+ *
+ * AT cannot be detected from JS (user privacy). We branch on *browser engine*
+ * as a coarse proxy for the most likely AT pairing on each platform:
+ *
+ * | Engine    | Assumed AT                   | Confidence              |
+ * |-----------|------------------------------|-------------------------|
+ * | WebKit    | VoiceOver (macOS/iOS)        | medium on Apple, low elsewhere |
+ * | Gecko     | NVDA (Win), Orca (Linux)     | medium on Win32, low elsewhere |
+ * | Chromium  | JAWS / NVDA / TalkBack       | high on non-Apple, medium on Apple |
+ *
+ * An explicit `data-a11y-strategy` attribute on the host element is always
+ * treated as `high` confidence (known override). If the override value does
+ * not match any registered strategy name, the resolver falls back to baseline
+ * with `low` confidence and logs an actionable warning.
+ *
+ * @param {HTMLElement} [host] - The component host element. When provided, its
+ *   `data-a11y-strategy` attribute is checked first.
+ * @returns {A11yStrategyResolution} The resolved strategy with confidence and reason.
+ */
+export function resolveStrategyDetailed(host) {
+  var _a, _b;
+  // Explicit override takes precedence over UA detection.
+  const override = (_a = host === null || host === void 0 ? void 0 : host.getAttribute('data-a11y-strategy')) !== null && _a !== void 0 ? _a : null;
+  if (override) {
+    const found = ALL_A11Y_STRATEGIES.find((s) => s.name === override);
+    if (found) {
+      return {
+        strategy: found,
+        confidence: 'high',
+        reason: `explicit override via data-a11y-strategy="${override}"`,
+      };
+    }
+    // Unknown override name — warn and fall back to baseline.
+    return {
+      strategy: baselineStrategy,
+      confidence: 'low',
+      reason: `unknown data-a11y-strategy="${override}"; known strategies: ${ALL_A11Y_STRATEGIES.map((s) => s.name).join(', ')}. Falling back to baseline.`,
+    };
+  }
+  // Read the runtime navigator explicitly from `globalThis` (not the bare
+  // `navigator` identifier, which build tooling may substitute). Delegate the
+  // pure UA→strategy mapping to `resolveStrategyFromEnv` so it can be unit
+  // tested deterministically without mocking globals.
+  const nav = globalThis.navigator;
+  return resolveStrategyFromEnv(nav === null || nav === void 0 ? void 0 : nav.userAgent, (_b = nav === null || nav === void 0 ? void 0 : nav.platform) !== null && _b !== void 0 ? _b : '');
+}
+/**
+ * Pure UA→strategy mapping. Separated from `resolveStrategyDetailed` so the
+ * browser-engine detection table can be unit tested deterministically by
+ * passing explicit `userAgent` / `platform` values instead of mocking the
+ * global `navigator` (which build/test tooling may sandbox).
+ *
+ * @param {string | undefined} userAgent - The `navigator.userAgent` string, or
+ *   `undefined` for an SSR / non-browser environment.
+ * @param {string} platform - The `navigator.platform` string (empty string when
+ *   unavailable).
+ * @returns {A11yStrategyResolution} The resolved strategy with confidence and reason.
+ */
+export function resolveStrategyFromEnv(userAgent, platform) {
+  // SSR / non-browser environment: no UA available.
+  if (userAgent === undefined) {
+    return {
+      strategy: baselineStrategy,
+      confidence: 'medium',
+      reason: 'no navigator (SSR or non-browser environment); baseline assumed',
+    };
+  }
+  const ua = userAgent;
+  // Order matters: Safari UA contains "Safari" but Chrome UA also does.
+  if (/\bFirefox\//.test(ua)) {
+    // Firefox + NVDA is the canonical pairing on Windows; on other
+    // platforms (macOS VoiceOver, Linux Orca, Windows JAWS) this is a
+    // probabilistic guess.
+    const isWindows = /Win/i.test(platform);
+    return {
+      strategy: firefoxNvdaStrategy,
+      confidence: isWindows ? 'medium' : 'low',
+      reason: isWindows
+        ? 'Firefox on Windows — assumed NVDA (most common pairing on Win32)'
+        : 'Firefox on non-Windows platform — AT pairing is a guess (may be Orca, VoiceOver, or JAWS)',
+    };
+  }
+  if (/^((?!chrome|android).)*safari/i.test(ua)) {
+    const isApple = /Mac|iPhone|iPad|iPod/i.test(platform);
+    return {
+      strategy: webkitVoiceOverStrategy,
+      confidence: isApple ? 'medium' : 'low',
+      reason: isApple
+        ? 'WebKit on Apple platform — assumed VoiceOver'
+        : 'WebKit on non-Apple platform — AT pairing is a guess',
+    };
+  }
+  // Chromium (Edge/Chrome). On macOS, Chromium routes through VoiceOver's
+  // accessibility tree; baseline covers most users but VoiceOver quirks may
+  // surface. Surfaced as medium confidence so the override path stays
+  // discoverable.
+  const onApple = /Mac|iPhone|iPad|iPod/i.test(platform);
+  return {
+    strategy: baselineStrategy,
+    confidence: onApple ? 'medium' : 'high',
+    reason: onApple
+      ? 'Chromium on Apple platform — VoiceOver may diverge from Chromium baseline'
+      : 'Chromium on non-Apple platform — baseline is the expected AT mapping',
+  };
+}
+/**
+ * Convenience wrapper for callers that only need the resolved strategy.
+ * Equivalent to `resolveStrategyDetailed(host).strategy` but additionally
+ * emits a **dev-mode console warning** for `low`-confidence resolutions,
+ * pointing engineers at the `data-a11y-strategy` override mechanism.
+ *
+ * The warning is rate-limited per `(strategyName, reason)` tuple to avoid
+ * log spam on every render cycle.
+ *
+ * @param {HTMLElement} [host] - The component host element (optional). Used for
+ *   the `data-a11y-strategy` override check.
+ * @returns {A11yTreeStrategy} The resolved strategy.
+ */
+export function resolveStrategy(host) {
+  const resolution = resolveStrategyDetailed(host);
+  if (resolution.confidence === 'low') {
+    warnOnce(resolution.strategy.name, resolution.reason);
+  }
+  return resolution.strategy;
+}
+const warnedKeys = new Set();
+/**
+ * Emit a console.warn once per (strategy, reason) tuple. Suppressed in
+ * production builds and when `console` is unavailable (SSR).
+ *
+ * @param {string} strategyName - Name of the resolved strategy.
+ * @param {string} reason - Human-readable reason for the resolution.
+ * @internal
+ */
+function warnOnce(strategyName, reason) {
+  var _a, _b;
+  if (typeof console === 'undefined')
+    return;
+  // Only warn in dev mode. Production builds set NODE_ENV=production;
+  // the guard below also handles minified bundles where `process` may
+  // be undefined.
+  const env = (_b = (_a = globalThis.process) === null || _a === void 0 ? void 0 : _a.env) === null || _b === void 0 ? void 0 : _b.NODE_ENV;
+  if (env === 'production')
+    return;
+  const key = `${strategyName}::${reason}`;
+  if (warnedKeys.has(key))
+    return;
+  warnedKeys.add(key);
+  console.warn(`[vega a11y-tree] Low-confidence strategy resolution: using "${strategyName}". ` +
+    `Reason: ${reason}. ` +
+    `Pin via data-a11y-strategy="<strategy-name>" to silence this warning ` +
+    `when you know the correct AT pairing. ` +
+    `Known strategies: ${ALL_A11Y_STRATEGIES.map((s) => s.name).join(', ')}.`);
+}

package/dist/collection/helpers/slimmers/a11y-tree-slimmer.js

@@ -0,0 +1,54 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MapToComponentField, MapToComponentMethod, VegaSlimmer } from 'vega-slimmer/core';
+import { applyA11yTree } from '../a11y-tree/a11y-tree-applier';
+/**
+ * Generic A11y Tree slimmer.
+ *
+ * Hooks `componentDidRender` and projects the component's semantic A11y
+ * Tree onto its shadow DOM using the strategy resolved for the current
+ * browser engine.
+ *
+ * ## Opt-in steps for a component
+ *
+ * 1. Tag render targets with `data-a11y-id="<stable-id>"` in the renderer.
+ * 2. Author a `build<Component>A11yTree(host)` function (see
+ *    `a11y-node-dto.ts` for the DTO helpers that make this ergonomic).
+ * 3. Inject this slimmer with `@InjectVegaSlimmer()`:
+ *
+ * ```ts
+ * @InjectVegaSlimmer()
+ * protected a11yTreeSlimmer = new A11yTreeSlimmer<HTMLVegaFooElement>(
+ *   host => buildFooA11yTree({ title: host.title, description: host.description }),
+ * );
+ * ```
+ *
+ * The slimmer handles strategy selection, patch application, and cleanup
+ * on every subsequent render.
+ *
+ * @template T - The concrete `HTMLElement` subtype for the component host.
+ */
+export class A11yTreeSlimmer extends VegaSlimmer {
+  constructor(buildA11yTree) {
+    super();
+    this.buildA11yTree = buildA11yTree;
+  }
+  /**
+   * Called by Stencil after each render. Projects the semantic A11y Tree
+   * onto the shadow DOM via the resolved browser-engine strategy.
+   */
+  projectA11yTree() {
+    const tree = this.buildA11yTree(this.host);
+    applyA11yTree(tree, this.host);
+  }
+}
+__decorate([
+  MapToComponentField()
+], A11yTreeSlimmer.prototype, "host", void 0);
+__decorate([
+  MapToComponentMethod('componentDidRender')
+], A11yTreeSlimmer.prototype, "projectA11yTree", null);

package/dist/collection/helpers/slimmers/element-appender/element-appender-slimmer.js

@@ -16,10 +16,12 @@ import { HoverTriggerStrategy } from './trigger-strategies/hover-trigger-strateg
 import { NoneTriggerStrategy } from './trigger-strategies/none-trigger-strategy';
 import { isEATriggerStrategy } from '../../../types/type-guard';
 import { tryGetDocument } from '../../../utils/try-get-document';
+import { ClipOnScrollModifier } from './visibility-modifiers/clip-on-scroll-modifier';
 export class ElementAppenderSlimmer extends VegaSlimmer {
   constructor(showConfigFactory, getTrigger, isDropdownShowName = 'isDropdownShow', disableInteractiveGetter = () => false) {
     super();
     this.hierarchyTreeManager = new ElementAppenderHierarchyTreeManager(this);
+    this.visibilityModifiers = [new ClipOnScrollModifier()];
     /**
      * It adds event listeners to the target and the appendable element
      */
@@ -125,6 +127,33 @@ export class ElementAppenderSlimmer extends VegaSlimmer {
         // itself, so no forced recalculation is needed there.
         const forceAdjust = !(e instanceof Event) || e.target !== tryGetDocument();
         (_a = this.elementAppender) === null || _a === void 0 ? void 0 : _a.onScroll(forceAdjust);
+        this.executeVisibilityModifiers({ kind: 'scroll', event: e });
+      }
+    };
+    /**
+     * Runs every enabled visibility modifier against the current show config and
+     * routes their actions to the appender. Modifiers are viewport-level,
+     * cross-cutting concerns that run in parallel with (not in place of) the
+     * selected trigger strategy — they only affect the appendable's visual
+     * clipping, never its logical open state.
+     */
+    this.executeVisibilityModifiers = (event) => {
+      if (!this.showConfig || !this.elementAppender)
+        return;
+      for (const modifier of this.visibilityModifiers) {
+        if (!modifier.isEnabled(this.showConfig))
+          continue;
+        const result = modifier.evaluate({
+          target: this.showConfig.target,
+          appendableElement: this.showConfig.appendableElement,
+          showConfig: this.showConfig,
+          currentState: { isVisible: this.isShowing() },
+          event,
+        });
+        if (result.nextAction === 'clip-hide')
+          this.elementAppender.setClipHidden(true);
+        else if (result.nextAction === 'clip-show')
+          this.elementAppender.setClipHidden(false);
       }
     };
     /* A timer that will hide the dropdown after a certain amount of time. */

package/dist/collection/helpers/slimmers/element-appender/visibility-modifiers/clip-on-scroll-modifier.js

@@ -0,0 +1,70 @@
+/**
+ * Returns the flattened-tree parent of a node so we can walk from inside a shadow
+ * tree up to the top-level document: assigned slot → parent element → shadow
+ * host.
+ *
+ * @param {Node} node - The node whose flattened-tree parent should be returned.
+ * @returns {HTMLElement | null} The flattened-tree parent, or null when the walk has reached the top.
+ */
+export function flatParent(node) {
+  var _a;
+  const slot = (_a = node.assignedSlot) !== null && _a !== void 0 ? _a : null;
+  if (slot)
+    return slot;
+  const parent = node.parentElement;
+  if (parent)
+    return parent;
+  const root = node.getRootNode();
+  return root.host ? root.host : null;
+}
+/**
+ * Returns true when the trigger is clipped out of view by the visual viewport
+ * or by any scrollable ancestor.
+ *
+ * @param {HTMLElement} target - The trigger element to test against the viewport and scrollable ancestors.
+ * @returns {boolean} True when the trigger is clipped and the appendable should be hidden.
+ */
+export function isTriggerClipped(target) {
+  const t = target.getBoundingClientRect();
+  const vw = window.innerWidth;
+  const vh = window.innerHeight;
+  if (t.bottom <= 0 || t.top >= vh || t.right <= 0 || t.left >= vw) {
+    return true;
+  }
+  let node = flatParent(target);
+  while (node) {
+    const style = getComputedStyle(node);
+    if (/(auto|scroll)/.test(style.overflowX + ' ' + style.overflowY)) {
+      const r = node.getBoundingClientRect();
+      if (t.bottom <= r.top || t.top >= r.bottom || t.right <= r.left || t.left >= r.right) {
+        return true;
+      }
+    }
+    node = flatParent(node);
+  }
+  return false;
+}
+/**
+ * Clip-hides an appendable while its trigger is scrolled out of view and
+ * restores it when the trigger returns, without touching the popup's logical
+ * open state. Applies to every appender consumer.
+ */
+export class ClipOnScrollModifier {
+  /**
+   * @returns {boolean} Always true — geometry alone decides clip vs restore in `evaluate`.
+   */
+  isEnabled() {
+    return true;
+  }
+  /**
+   * Evaluates whether the appendable should be clip-hidden or restored based
+   * on the current trigger geometry.
+   *
+   * @param {VegaEAVisibilityContext} context - Evaluation context.
+   * @returns {VegaEAVisibilityResult} The next clip action.
+   */
+  evaluate(context) {
+    const clipped = isTriggerClipped(context.target);
+    return { nextAction: clipped ? 'clip-hide' : 'clip-show' };
+  }
+}

package/dist/collection/helpers/slimmers/element-appender/visibility-modifiers/visibility-modifier.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/helpers/ui/element-appender.js

@@ -111,6 +111,22 @@ export class ElementAppender {
       this.adjustPosition(true);
     }
   }
+  /**
+   * Toggles the appendable's visibility without changing its logical open
+   * state. Used to visually clip the popup when the trigger is out of view.
+   *
+   * @param {boolean} clipped - true to hide, false to show
+   */
+  setClipHidden(clipped) {
+    if (!this.showConfig)
+      return;
+    if (clipped) {
+      this.hideElementAppender(this.showConfig.appendableElement);
+    }
+    else {
+      this.showElementAppender(this.showConfig.appendableElement);
+    }
+  }
   /* istanbul ignore next */
   /**
    * It removes the z-index from the appendable element, removes the appendable element from the DOM, and

package/dist/esm/{app-globals-eafcc7a1.js → app-globals-d7b651c1.js}

@@ -1,6 +1,6 @@
 import { F as FeatureFlag } from './feature-flag-controller-3fd04ea9.js';
-import { V as VegaLoader, a as VegaNotify, b as VegaEventManager, c as VegaZIndexManager, w as waitForVega, d as VegaSkeletonLoader, e as VegaTranslation, f as VegaRTETokenExtension, g as VegaRTELanguageExtension, h as VegaRTEDefaultLineHeightOptions, i as VegaRTEFunctionExtension, j as VegaRTETableExtension, k as VegaRTEHorizontalLineExtension, l as VegaRTEBlockquoteExtension, m as VegaRTESpecialCharactersExtension, n as VegaRTEFindReplaceExtension, o as VegaRTESpecialCharactersEssentials, p as VegaRTESpecialCharactersLatin, q as VegaRTESpecialCharactersMathematical, r as VegaRTESpecialCharactersArrows, s as VegaRTESpecialCharactersCurrency, t as VegaRTESpecialCharactersText, u as VegaRTELineHeightExtension, v as VegaRTEPasteExtension, x as VegaRTEFullscreenExtension, y as VegaRTECopyExtension, z as VegaRTECutExtension, A as VegaCalendarPeriodFactory } from './token-extension-f5bf9c21.js';
-import { V as VegaThemeManager } from './split-cell-operation-359f8082.js';
+import { V as VegaLoader, a as VegaNotify, b as VegaEventManager, c as VegaZIndexManager, w as waitForVega, d as VegaSkeletonLoader, e as VegaTranslation, f as VegaRTETokenExtension, g as VegaRTELanguageExtension, h as VegaRTEDefaultLineHeightOptions, i as VegaRTEFunctionExtension, j as VegaRTETableExtension, k as VegaRTEHorizontalLineExtension, l as VegaRTEBlockquoteExtension, m as VegaRTESpecialCharactersExtension, n as VegaRTEFindReplaceExtension, o as VegaRTESpecialCharactersEssentials, p as VegaRTESpecialCharactersLatin, q as VegaRTESpecialCharactersMathematical, r as VegaRTESpecialCharactersArrows, s as VegaRTESpecialCharactersCurrency, t as VegaRTESpecialCharactersText, u as VegaRTELineHeightExtension, v as VegaRTEPasteExtension, x as VegaRTEFullscreenExtension, y as VegaRTECopyExtension, z as VegaRTECutExtension, A as VegaCalendarPeriodFactory } from './token-extension-40c32bcc.js';
+import { V as VegaThemeManager } from './split-cell-operation-7f3058ad.js';
 import { M as MapToComponentMethod, V as VegaSlimmer, s as setVegaLogLevel, G as GlobalSlimmersRegistry } from './global-slimmer-registry-17c4efd4.js';
 import { V as VegaDialog } from './vega-dialog-controller-726b74f9.js';
 import { T as TypographyUrls } from './typography-19c3b9be.js';
@@ -12,12 +12,12 @@ import { U as UPDATE_TRANSLATION } from './static-subject-title-1c86e974.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
 import { O as Observer } from './observer-3959f9dd.js';
 import { f as forceUpdate } from './index-090d31ca.js';
-import { V as VegaRTEContent } from './content-state-8032467a.js';
+import { V as VegaRTEContent } from './content-state-79ca99e5.js';
 import { v as vegaNonceManager, s as setVegaNonce } from './vega-nonce-manager-497e5eb5.js';
-import { V as VegaRTEPresetToolbarItems } from './code-block-e12588fe.js';
-import { V as VegaRTELinkExtension } from './link-extension-97fcb8fb.js';
+import { V as VegaRTEPresetToolbarItems } from './code-block-0a88b481.js';
+import { V as VegaRTELinkExtension } from './link-extension-09534514.js';
 import './type-guard-ec5e8628.js';
-import { V as VegaRTEImageExtension } from './image-extension-b6c7e4a7.js';
+import { V as VegaRTEImageExtension } from './image-extension-48a96f98.js';
 
 var __decorate$2 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -424,7 +424,7 @@ function injectVegaCalendarPeriodFactoryIntoGlobal() {
  * Inject VegaPublicValidationRules to global as a public api
  */
 function injectVegaPublicValidationRules() {
-  void import('./public-rules-c06f0d2a.js').then((module) => {
+  void import('./public-rules-5eb03ef0.js').then((module) => {
     Object.entries(module).forEach(([name, value]) => {
       globalThis[name] = value;
     });