@pie-players/pie-players-shared 0.3.69 → 0.3.71

package/dist/security/sanitize-style-attribute.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Declaration-level filter for the `style` attribute on authored markup and
+ * tool icons.
+ *
+ * DOMPurify lists `style` among its URI-safe attributes, so it permits the
+ * attribute and inspects nothing inside it. Two things in an inline style
+ * therefore reach the page unchecked: a URL-fetching function, which makes the
+ * browser request an arbitrary origin every time the item renders and reports
+ * back which learner saw which item, and `position: fixed`, which leaves the
+ * item's box and covers the host page — the item player renders in light DOM
+ * (`shadow: "none"`), so nothing else confines it.
+ *
+ * What stays permitted is the point of filtering declarations rather than
+ * dropping the attribute: authored items use inline styles for ordinary
+ * per-element presentation, and `position: absolute` in particular is
+ * load-bearing for accessibility — MathJax's `mjx-assistive-mml` carries
+ * `position: absolute; width: 1px; height: 1px; overflow: hidden` to expose
+ * MathML to a screen reader while hiding it visually.
+ *
+ * `position: absolute` and `position: sticky` are deliberately left alone.
+ * Sticky cannot leave its containing block, so it is not an escape. Absolute
+ * can, when no ancestor between the node and the viewport is positioned, and
+ * closing that means making the player's own container a containing block
+ * rather than filtering the declaration — a change that re-anchors every
+ * absolutely positioned node a PIE element renders, so it is a separate
+ * decision with its own visual review.
+ */
+/**
+ * Filter one `style` attribute value.
+ *
+ * Returns the input unchanged when nothing needs removing, so authored markup
+ * keeps its own spelling — shorthands stay shorthands — in every case but the
+ * one that carries something forbidden.
+ */
+export declare function sanitizeStyleAttribute(value: unknown, doc: Document | null | undefined): string;
+/** The subset of a DOMPurify instance this hook needs. */
+export interface StyleAttributeHookTarget {
+    addHook?: (entryPoint: string, hook: (node: unknown, data?: unknown) => void) => void;
+}
+/**
+ * Install the filter on a DOMPurify instance.
+ *
+ * `afterSanitizeAttributes` rather than a post-pass over the output string:
+ * DOMPurify has already parsed the markup at that point, so the declarations
+ * are filtered on the node it is about to serialize instead of costing another
+ * DOM round-trip.
+ */
+export declare function installStyleAttributeHook(purifier: StyleAttributeHookTarget): void;

package/dist/security/sanitize-style-attribute.js

@@ -0,0 +1,129 @@
+/**
+ * Declaration-level filter for the `style` attribute on authored markup and
+ * tool icons.
+ *
+ * DOMPurify lists `style` among its URI-safe attributes, so it permits the
+ * attribute and inspects nothing inside it. Two things in an inline style
+ * therefore reach the page unchecked: a URL-fetching function, which makes the
+ * browser request an arbitrary origin every time the item renders and reports
+ * back which learner saw which item, and `position: fixed`, which leaves the
+ * item's box and covers the host page — the item player renders in light DOM
+ * (`shadow: "none"`), so nothing else confines it.
+ *
+ * What stays permitted is the point of filtering declarations rather than
+ * dropping the attribute: authored items use inline styles for ordinary
+ * per-element presentation, and `position: absolute` in particular is
+ * load-bearing for accessibility — MathJax's `mjx-assistive-mml` carries
+ * `position: absolute; width: 1px; height: 1px; overflow: hidden` to expose
+ * MathML to a screen reader while hiding it visually.
+ *
+ * `position: absolute` and `position: sticky` are deliberately left alone.
+ * Sticky cannot leave its containing block, so it is not an escape. Absolute
+ * can, when no ancestor between the node and the viewport is positioned, and
+ * closing that means making the player's own container a containing block
+ * rather than filtering the declaration — a change that re-anchors every
+ * absolutely positioned node a PIE element renders, so it is a separate
+ * decision with its own visual review.
+ */
+/**
+ * CSS functions that make the browser fetch a URL. Serialized CSSOM values are
+ * matched against this, so an escaped spelling (`\75 rl(`) is normalized to
+ * `url(` before it gets here.
+ */
+const URL_FUNCTION_REGEX = /(?:^|[^\w-])(?:url|image-set|-webkit-image-set|src)\s*\(/i;
+/**
+ * Cheap gate on the raw attribute so the common case costs one regex and no
+ * CSSOM parse. `position` is included because that check needs the parser, and
+ * a backslash because it introduces a CSS escape, which is exactly how a
+ * forbidden token hides from a raw-string match.
+ */
+const NEEDS_INSPECTION_REGEX = /url\s*\(|image-set\s*\(|src\s*\(|position|\\/i;
+function isForbiddenDeclaration(property, value) {
+    if (URL_FUNCTION_REGEX.test(value))
+        return true;
+    // `position` is a shorthand for nothing, so the CSSOM reports it verbatim.
+    return property.toLowerCase() === "position" && /\bfixed\b/i.test(value);
+}
+/**
+ * Rebuild the attribute from the parsed declarations, dropping the forbidden
+ * ones. Anything the engine failed to parse is dropped with them: an unparsed
+ * declaration cannot be inspected, and this path only runs on input that
+ * already tripped the gate.
+ */
+function rebuildFromCssom(value, doc) {
+    const probe = doc.createElement("span");
+    probe.setAttribute("style", value);
+    const declarations = probe.style;
+    const kept = [];
+    for (let index = 0; index < declarations.length; index += 1) {
+        const property = declarations.item(index);
+        if (!property)
+            continue;
+        const propertyValue = declarations.getPropertyValue(property);
+        if (isForbiddenDeclaration(property, propertyValue))
+            continue;
+        const priority = declarations.getPropertyPriority(property);
+        kept.push(`${property}: ${propertyValue}${priority ? ` !${priority}` : ""}`);
+    }
+    return kept.join("; ");
+}
+/**
+ * Filter one `style` attribute value.
+ *
+ * Returns the input unchanged when nothing needs removing, so authored markup
+ * keeps its own spelling — shorthands stay shorthands — in every case but the
+ * one that carries something forbidden.
+ */
+export function sanitizeStyleAttribute(value, doc) {
+    if (typeof value !== "string" || value.length === 0)
+        return "";
+    if (!doc)
+        return value;
+    if (!NEEDS_INSPECTION_REGEX.test(value))
+        return value;
+    const probe = doc.createElement("span");
+    probe.setAttribute("style", value);
+    const declarations = probe.style;
+    let hasForbidden = false;
+    for (let index = 0; index < declarations.length; index += 1) {
+        const property = declarations.item(index);
+        if (!property)
+            continue;
+        if (isForbiddenDeclaration(property, declarations.getPropertyValue(property))) {
+            hasForbidden = true;
+            break;
+        }
+    }
+    // A raw value carrying a URL function the engine did not parse into a
+    // declaration still goes through the rebuild, which drops it.
+    if (!hasForbidden && !URL_FUNCTION_REGEX.test(value))
+        return value;
+    return rebuildFromCssom(value, doc);
+}
+/**
+ * Install the filter on a DOMPurify instance.
+ *
+ * `afterSanitizeAttributes` rather than a post-pass over the output string:
+ * DOMPurify has already parsed the markup at that point, so the declarations
+ * are filtered on the node it is about to serialize instead of costing another
+ * DOM round-trip.
+ */
+export function installStyleAttributeHook(purifier) {
+    if (typeof purifier.addHook !== "function")
+        return;
+    purifier.addHook("afterSanitizeAttributes", (node) => {
+        const element = node;
+        if (!element || typeof element.getAttribute !== "function")
+            return;
+        const raw = element.getAttribute("style");
+        if (!raw)
+            return;
+        const filtered = sanitizeStyleAttribute(raw, element.ownerDocument);
+        if (filtered === raw)
+            return;
+        if (filtered)
+            element.setAttribute("style", filtered);
+        else
+            element.removeAttribute("style");
+    });
+}

package/dist/security/sanitize-svg-icon.js

@@ -11,6 +11,7 @@
  */
 import DOMPurify from "dompurify";
 import { SANITIZER_FORBIDDEN_ATTRS, SANITIZER_FORBIDDEN_TAGS, } from "./sanitize-forbidden-lists.js";
+import { installStyleAttributeHook } from "./sanitize-style-attribute.js";
 let svgPurifierInstance = null;
 function resolveSvgPurifier() {
     if (svgPurifierInstance)
@@ -22,6 +23,7 @@ function resolveSvgPurifier() {
         typeof factory === "function"
             ? factory(window)
             : DOMPurify;
+    installStyleAttributeHook(svgPurifierInstance);
     return svgPurifierInstance;
 }
 const FORBIDDEN_TAGS = SANITIZER_FORBIDDEN_TAGS;

package/dist/security/validate-style-url.d.ts

@@ -8,6 +8,13 @@
  * - When `allowedOrigins` is non-empty, the URL's origin must match one
  *   of the listed origins. This lets hosts restrict style loading to a
  *   known CDN allow-list.
+ * - With no allow-list configured, only same-origin URLs pass. The reachable
+ *   input here is authored — `itemConfig.resources.stylesheets[*].url` — so an
+ *   open default let an item pull page-wide CSS from any origin it named, and
+ *   the cross-origin branch in the player is the one that cannot be scoped
+ *   (CSS the browser applies from a `<link>` rather than text the player
+ *   fetched and rewrote). Naming an origin in `allowed-style-origins` is a
+ *   host's opt-in to that.
  */
 export type StyleUrlValidationOk = {
     ok: true;
@@ -20,6 +27,12 @@ export type StyleUrlValidationError = {
 };
 export type StyleUrlValidationResult = StyleUrlValidationOk | StyleUrlValidationError;
 export interface StyleUrlValidationOptions {
+    /**
+     * Document URL the stylesheet URL resolves against, and the origin a URL is
+     * compared to when no `allowedOrigins` are configured. Omitting it while
+     * supplying no allow-list leaves no origin to compare against, so
+     * cross-origin cannot be ruled out and the URL is rejected.
+     */
     baseUrl?: string;
     allowedOrigins?: string[];
 }

package/dist/security/validate-style-url.js

@@ -8,6 +8,13 @@
  * - When `allowedOrigins` is non-empty, the URL's origin must match one
  *   of the listed origins. This lets hosts restrict style loading to a
  *   known CDN allow-list.
+ * - With no allow-list configured, only same-origin URLs pass. The reachable
+ *   input here is authored — `itemConfig.resources.stylesheets[*].url` — so an
+ *   open default let an item pull page-wide CSS from any origin it named, and
+ *   the cross-origin branch in the player is the one that cannot be scoped
+ *   (CSS the browser applies from a `<link>` rather than text the player
+ *   fetched and rewrote). Naming an origin in `allowed-style-origins` is a
+ *   host's opt-in to that.
  */
 export function validateExternalStyleUrl(url, options = {}) {
     if (typeof url !== "string" || url.length === 0) {
@@ -38,11 +45,38 @@ export function validateExternalStyleUrl(url, options = {}) {
         };
     }
     const allowed = options.allowedOrigins ?? [];
-    if (allowed.length > 0 && !allowed.includes(resolvedUrl.origin)) {
+    if (allowed.length > 0) {
+        if (!allowed.includes(resolvedUrl.origin)) {
+            return {
+                ok: false,
+                reason: "disallowed-origin",
+                message: `External stylesheet origin ${resolvedUrl.origin} is not in the configured allow-list.`,
+            };
+        }
+        return { ok: true, resolvedUrl };
+    }
+    // No allow-list: same-origin only.
+    let baseOrigin = null;
+    if (options.baseUrl) {
+        try {
+            baseOrigin = new URL(options.baseUrl).origin;
+        }
+        catch {
+            baseOrigin = null;
+        }
+    }
+    if (baseOrigin === null) {
+        return {
+            ok: false,
+            reason: "disallowed-origin",
+            message: "External stylesheet origin cannot be checked: no allow-list is configured and no usable baseUrl was supplied. Pass allowedOrigins to permit a cross-origin stylesheet.",
+        };
+    }
+    if (resolvedUrl.origin !== baseOrigin) {
         return {
             ok: false,
             reason: "disallowed-origin",
-            message: `External stylesheet origin ${resolvedUrl.origin} is not in the configured allow-list.`,
+            message: `External stylesheet origin ${resolvedUrl.origin} is cross-origin and no allow-list is configured. Add it to \`allowed-style-origins\` to permit it.`,
         };
     }
     return { ok: true, resolvedUrl };

package/dist/security/wrap-overwide-images.d.ts

@@ -49,3 +49,10 @@ export declare function wrapOverwideImagesInElement(root: Element, options?: Wra
  *   to wrap element-rendered images.
  */
 export declare function wrapOverwideImages(markup: string): string;
+/**
+ * True when `record` mentions nothing but the output of
+ * {@link wrapOverwideImagesInElement} — a `pie-image-scroll` wrapper, or an
+ * `<img>` moving inside one. An observer-driven caller ignores such a record so
+ * its own wrap does not schedule a second pass.
+ */
+export declare function isOverwideImageWrapMutation(record: MutationRecord): boolean;

package/dist/security/wrap-overwide-images.js

@@ -26,7 +26,7 @@
  * The wrapping itself lives in `./wrap-overwide.js`, shared with the table
  * wrapper: only the four values below and the accessible name differ.
  */
-import { wrapOverwideInElement, wrapOverwideMarkup, } from "./wrap-overwide.js";
+import { isOverwideWrapMutation, wrapOverwideInElement, wrapOverwideMarkup, } from "./wrap-overwide.js";
 function buildAriaLabel(image) {
     const alt = image.getAttribute("alt");
     const trimmed = alt ? alt.trim() : "";
@@ -64,3 +64,12 @@ export function wrapOverwideImagesInElement(root, options = {}) {
 export function wrapOverwideImages(markup) {
     return wrapOverwideMarkup(markup, IMAGE_SPEC);
 }
+/**
+ * True when `record` mentions nothing but the output of
+ * {@link wrapOverwideImagesInElement} — a `pie-image-scroll` wrapper, or an
+ * `<img>` moving inside one. An observer-driven caller ignores such a record so
+ * its own wrap does not schedule a second pass.
+ */
+export function isOverwideImageWrapMutation(record) {
+    return isOverwideWrapMutation(record, IMAGE_SPEC);
+}

package/dist/security/wrap-overwide-tables.d.ts

@@ -35,3 +35,10 @@ export type WrapOverwideTablesInElementOptions = WrapOverwideOptions;
  */
 export declare function wrapOverwideTablesInElement(root: Element, options?: WrapOverwideTablesInElementOptions): number;
 export declare function wrapOverwideTables(markup: string): string;
+/**
+ * True when `record` mentions nothing but the output of
+ * {@link wrapOverwideTablesInElement} — a `pie-table-scroll` wrapper, or a
+ * `<table>` moving inside one. An observer-driven caller ignores such a record
+ * so its own wrap does not schedule a second pass.
+ */
+export declare function isOverwideTableWrapMutation(record: MutationRecord): boolean;

package/dist/security/wrap-overwide-tables.js

@@ -26,7 +26,7 @@
  * The wrapping itself lives in `./wrap-overwide.js`, shared with the image
  * wrapper: only the four values below and the accessible name differ.
  */
-import { wrapOverwideInElement, wrapOverwideMarkup, } from "./wrap-overwide.js";
+import { isOverwideWrapMutation, wrapOverwideInElement, wrapOverwideMarkup, } from "./wrap-overwide.js";
 function buildAriaLabel(table) {
     // Authors commonly label tables via <caption>, aria-label, or aria-labelledby.
     // Prefer the most explicit signal and fall back to the generic label so
@@ -75,3 +75,12 @@ export function wrapOverwideTablesInElement(root, options = {}) {
 export function wrapOverwideTables(markup) {
     return wrapOverwideMarkup(markup, TABLE_SPEC);
 }
+/**
+ * True when `record` mentions nothing but the output of
+ * {@link wrapOverwideTablesInElement} — a `pie-table-scroll` wrapper, or a
+ * `<table>` moving inside one. An observer-driven caller ignores such a record
+ * so its own wrap does not schedule a second pass.
+ */
+export function isOverwideTableWrapMutation(record) {
+    return isOverwideWrapMutation(record, TABLE_SPEC);
+}

package/dist/security/wrap-overwide.d.ts

@@ -49,3 +49,19 @@ export declare function wrapOverwideInElement(root: Element, spec: OverwideWrapS
  * is returned unchanged and the browser re-run on hydrate performs the wrap.
  */
 export declare function wrapOverwideMarkup(markup: string, spec: OverwideWrapSpec): string;
+/**
+ * True when `record` mentions nothing but this module's own live-DOM output for
+ * `spec`: a wrapper landing beside the node it wraps, or that node moving inside
+ * it.
+ *
+ * An observer-driven caller re-runs {@link wrapOverwideInElement} on every
+ * mutation tick, and the wrap itself inserts elements — so without this test the
+ * pass retriggers the observer that scheduled it, converging only because the
+ * wrap is idempotent. Ignoring the pass's own records is what removes the
+ * retrigger; a PIE element that re-renders over its own subtree and drops the
+ * wrapper is the case where absorbing it instead becomes a sustained loop.
+ *
+ * Conservative in the safe direction: anything it cannot account for reads as
+ * foreign, which costs one extra pass and never a missed wrap.
+ */
+export declare function isOverwideWrapMutation(record: MutationRecord, spec: OverwideWrapSpec): boolean;

package/dist/security/wrap-overwide.js

@@ -89,3 +89,55 @@ export function wrapOverwideMarkup(markup, spec) {
     });
     return wrapped > 0 ? body.innerHTML : markup;
 }
+function isElement(node) {
+    return node.nodeType === 1;
+}
+/** A `spec` wrapper holding nothing but the nodes `spec` wraps. */
+function isWrapperFor(node, spec) {
+    if (!isElement(node))
+        return false;
+    if (!node.classList?.contains(spec.wrapperClass))
+        return false;
+    for (const child of Array.from(node.children)) {
+        if (!child.matches(spec.selector))
+            return false;
+    }
+    return true;
+}
+/** A node `spec` wraps, currently held by a `spec` wrapper. */
+function isWrappedBy(node, spec) {
+    if (!isElement(node))
+        return false;
+    const parent = node.parentElement;
+    if (!parent?.classList?.contains(spec.wrapperClass))
+        return false;
+    return node.matches(spec.selector);
+}
+function everyNodeIsWrapOutput(nodes, spec) {
+    for (const node of Array.from(nodes)) {
+        if (!isWrapperFor(node, spec) && !isWrappedBy(node, spec))
+            return false;
+    }
+    return true;
+}
+/**
+ * True when `record` mentions nothing but this module's own live-DOM output for
+ * `spec`: a wrapper landing beside the node it wraps, or that node moving inside
+ * it.
+ *
+ * An observer-driven caller re-runs {@link wrapOverwideInElement} on every
+ * mutation tick, and the wrap itself inserts elements — so without this test the
+ * pass retriggers the observer that scheduled it, converging only because the
+ * wrap is idempotent. Ignoring the pass's own records is what removes the
+ * retrigger; a PIE element that re-renders over its own subtree and drops the
+ * wrapper is the case where absorbing it instead becomes a sustained loop.
+ *
+ * Conservative in the safe direction: anything it cannot account for reads as
+ * foreign, which costs one extra pass and never a missed wrap.
+ */
+export function isOverwideWrapMutation(record, spec) {
+    if (record.type !== "childList")
+        return false;
+    return (everyNodeIsWrapOutput(record.addedNodes, spec) &&
+        everyNodeIsWrapOutput(record.removedNodes, spec));
+}

package/dist/ui/overlay-containment.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Containment for tool overlays that position themselves.
+ *
+ * An overlay that draws its own surface computes its own coordinates, and those
+ * coordinates are only meaningful against the box the browser resolved as its
+ * containing block. Reading that box from the element rather than from
+ * `window` is what keeps a tool correct wherever a host mounts it: the same
+ * numbers that centre a tool in the viewport put it outside a pane.
+ */
+/** Distance kept clear of the block's edges so an overlay's controls stay reachable. */
+export declare const DEFAULT_CONTAINMENT_GUTTER = 4;
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * The box `element` resolves its `left`/`top` against: its containing block, or
+ * the viewport when that is the initial containing block.
+ *
+ * `offsetParent` is the containing block as the browser resolved it, including
+ * across a shadow boundary, which is what makes this correct for a tool mounted
+ * by a host it knows nothing about. Returns `undefined` outside a browser.
+ */
+export declare function resolveContainingBlockRect(element: HTMLElement | undefined | null): DOMRect | undefined;
+/**
+ * Clamps a translate offset applied to a box that is already centred in its
+ * containing block, so the box stays inside it.
+ *
+ * The travel available on each axis is symmetric about the centre: half the
+ * block, less half the box and the gutter. A box wider or taller than its block
+ * cannot satisfy that on the offending axis, so it stays centred there rather
+ * than clamping to an inverted range.
+ */
+export declare function clampOffsetWithinBlock(offset: Point, box: Size, block: Size, gutter?: number): Point;
+/**
+ * Clamps an absolute centre point, in containing-block coordinates, so the box
+ * it positions stays inside that block.
+ *
+ * The same invariant as `clampOffsetWithinBlock` in the coordinate system an
+ * overlay uses when it writes `left`/`top` instead of translating: the two are
+ * conjugate by a translation of half the block, including the degenerate case
+ * where a box exceeds its block and centres on the offending axis.
+ */
+export declare function clampPointWithinBlock(point: Point, box: Size, block: Size, gutter?: number): Point;

package/dist/ui/overlay-containment.js

@@ -0,0 +1,65 @@
+/**
+ * Containment for tool overlays that position themselves.
+ *
+ * An overlay that draws its own surface computes its own coordinates, and those
+ * coordinates are only meaningful against the box the browser resolved as its
+ * containing block. Reading that box from the element rather than from
+ * `window` is what keeps a tool correct wherever a host mounts it: the same
+ * numbers that centre a tool in the viewport put it outside a pane.
+ */
+/** Distance kept clear of the block's edges so an overlay's controls stay reachable. */
+export const DEFAULT_CONTAINMENT_GUTTER = 4;
+/**
+ * The box `element` resolves its `left`/`top` against: its containing block, or
+ * the viewport when that is the initial containing block.
+ *
+ * `offsetParent` is the containing block as the browser resolved it, including
+ * across a shadow boundary, which is what makes this correct for a tool mounted
+ * by a host it knows nothing about. Returns `undefined` outside a browser.
+ */
+export function resolveContainingBlockRect(element) {
+    if (typeof window === "undefined" || !element)
+        return undefined;
+    const parent = element.offsetParent;
+    if (parent instanceof HTMLElement) {
+        const rect = parent.getBoundingClientRect();
+        if (rect.width > 0 && rect.height > 0)
+            return rect;
+    }
+    return new DOMRect(0, 0, window.innerWidth, window.innerHeight);
+}
+/**
+ * Clamps a translate offset applied to a box that is already centred in its
+ * containing block, so the box stays inside it.
+ *
+ * The travel available on each axis is symmetric about the centre: half the
+ * block, less half the box and the gutter. A box wider or taller than its block
+ * cannot satisfy that on the offending axis, so it stays centred there rather
+ * than clamping to an inverted range.
+ */
+export function clampOffsetWithinBlock(offset, box, block, gutter = DEFAULT_CONTAINMENT_GUTTER) {
+    const clampAxis = (value, boxExtent, blockExtent) => {
+        const travel = blockExtent / 2 - boxExtent / 2 - gutter;
+        if (travel <= 0)
+            return 0;
+        return Math.max(-travel, Math.min(travel, value));
+    };
+    return {
+        x: clampAxis(offset.x, box.width, block.width),
+        y: clampAxis(offset.y, box.height, block.height),
+    };
+}
+/**
+ * Clamps an absolute centre point, in containing-block coordinates, so the box
+ * it positions stays inside that block.
+ *
+ * The same invariant as `clampOffsetWithinBlock` in the coordinate system an
+ * overlay uses when it writes `left`/`top` instead of translating: the two are
+ * conjugate by a translation of half the block, including the degenerate case
+ * where a box exceeds its block and centres on the offending axis.
+ */
+export function clampPointWithinBlock(point, box, block, gutter = DEFAULT_CONTAINMENT_GUTTER) {
+    const centre = { x: block.width / 2, y: block.height / 2 };
+    const offset = clampOffsetWithinBlock({ x: point.x - centre.x, y: point.y - centre.y }, box, block, gutter);
+    return { x: centre.x + offset.x, y: centre.y + offset.y };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pie-players/pie-players-shared",
-	"version": "0.3.69",
+	"version": "0.3.71",
 	"type": "module",
 	"description": "Shared runtime + UI utilities for PIE players",
 	"license": "MIT",
@@ -89,10 +89,6 @@
 			"types": "./dist/components/vendor/nds/nds-icon-button.d.ts",
 			"import": "./dist/components/vendor/nds/nds-icon-button.js"
 		},
-		"./ui/zoom-compensation": {
-			"types": "./dist/ui/zoom-compensation.d.ts",
-			"import": "./dist/ui/zoom-compensation.js"
-		},
 		"./ui/content-styles": {
 			"types": "./dist/ui/content-styles.d.ts",
 			"import": "./dist/ui/content-styles.js"
@@ -107,7 +103,7 @@
 	],
 	"dependencies": {
 		"@pie-lib/math-rendering-module": "6.0.0",
-		"dompurify": "^3.4.13",
+		"dompurify": "^3.4.14",
 		"semver": "^7.8.5"
 	},
 	"scripts": {
@@ -116,18 +112,18 @@
 		"typecheck": "tsc -p tsconfig.json --noEmit",
 		"lint": "biome check .",
 		"check": "tsc -p tsconfig.json --noEmit",
-		"test": "bun test '.test.ts'",
+		"test": "bun test",
 		"check-i18n": "bun run src/i18n/scripts/check-coverage.ts",
 		"scan-hardcoded": "bun run src/i18n/scripts/scan-hardcoded.ts"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.5.10",
-		"@happy-dom/global-registrator": "^20.11.6",
+		"@biomejs/biome": "^2.5.11",
+		"@happy-dom/global-registrator": "^20.11.15",
 		"@playwright/test": "^1.62.1",
 		"@types/semver": "^7.8.0",
 		"esbuild": "^0.28.2",
 		"glob": "^13.0.0",
-		"svelte": "^5.56.10",
+		"svelte": "^5.57.0",
 		"typescript": "^5.9.3"
 	},
 	"homepage": "https://github.com/pie-framework/pie-players/tree/master/packages/players-shared#readme",

package/dist/ui/zoom-compensation.d.ts

@@ -1,44 +0,0 @@
-/**
- * Pure browser-zoom compensation math (framework-agnostic, no Svelte runes).
- *
- * Browser zoom is approximated as outerWidth / innerWidth: outerWidth is the
- * OS window size (zoom-independent) while innerWidth is in CSS pixels (shrinks
- * as zoom increases). Callers apply the returned factor via CSS `zoom` so an
- * element that would otherwise keep enlarging past `maxZoom` compounds back
- * down to the cap.
- *
- * This module is tsc-buildable and shipped in `dist`, so it can be consumed by
- * packages that resolve `@pie-players/pie-players-shared` from its published
- * build (e.g. the assessment-toolkit CE bundle) as well as by the reactive
- * Svelte wrapper in `./use-zoom-compensation.svelte.ts`, which packages built
- * with Vite alias to source.
- */
-export type ZoomCompensationOptions = {
-    /**
-     * Zoom level (as a ratio, e.g. `2` for 200%) below which the factor is 1.
-     * Above this level the factor shrinks as `maxZoom / zoom`.
-     */
-    maxZoom: number;
-    /** Lower bound on the returned factor. */
-    minCompensation: number;
-};
-/**
- * Shared zoom-cap settings for the toolbar icon buttons (the TTS play button and
- * the calculator button) so both compensate identically and can't drift apart.
- * Grow normally up to 200%, then freeze; the 0.25 floor keeps the cap holding
- * past 500% browser zoom (see the minCompensation note in
- * section-player's SectionPlayerTabbedContent).
- */
-export declare const ICON_BUTTON_ZOOM_OPTIONS: ZoomCompensationOptions;
-/**
- * Approximate the browser zoom level from an outer/inner width pair. Falls
- * back to 1 (100%) if the ratio isn't finite or is non-positive (which happens
- * during SSR, in headless envs, and briefly during resize on some browsers).
- */
-export declare function approximateZoomFromWidths(outerWidth: number, innerWidth: number): number;
-/**
- * Pure zoom-compensation math: exactly 1 at zoom <= maxZoom, then shrinks as
- * `maxZoom / zoom`, floored at `minCompensation` to guard against inflated
- * ratios from window chrome / side panels making the element unusably small.
- */
-export declare function computeZoomCompensation(zoom: number, maxZoom: number, minCompensation: number): number;