hyperframes 0.8.142 → 0.8.144

package/dist/{chunk-OSUKETIH.js → chunk-5WADG7PR.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   resolveCaptureBrowserGpuMode
-} from "./chunk-WTMUCJ6Z.js";
+} from "./chunk-7SDCIWHQ.js";
 import {
   requestCliExit
 } from "./chunk-PBN6GBJE.js";

package/dist/{chunk-JYYOAKHS.js → chunk-6IIGT7BX.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   downloadFile
-} from "./chunk-WCJGTLPF.js";
+} from "./chunk-BHVFTYSI.js";
 
 // src/tts/manager.ts
 import { existsSync, mkdirSync } from "fs";

package/dist/{chunk-6UYZB4TY.js → chunk-7RAYSCYT.js}

@@ -6,20 +6,20 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   errorBox
-} from "./chunk-IHFUKJOR.js";
+} from "./chunk-K2FLNJVB.js";
 import {
   ensureDOMParser
-} from "./chunk-PFCFR3KZ.js";
+} from "./chunk-442JNXRM.js";
 import {
   failCommand
 } from "./chunk-PBN6GBJE.js";
 import {
   formatVariableValidationIssue,
   validateVariables
-} from "./chunk-YFT3BL7N.js";
+} from "./chunk-3VYNNWVA.js";
 import {
   extractCompositionMetadata
-} from "./chunk-OZUQF4NB.js";
+} from "./chunk-MQZVBHEY.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";

package/dist/{chunk-WTMUCJ6Z.js → chunk-7SDCIWHQ.js}

@@ -4,6 +4,10 @@ import { dirname as __hf_dirname } from "node:path";
 var require = __hf_createRequire(import.meta.url);
 var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
+import {
+  resolveConfig,
+  usesSoftwareWebGpu
+} from "./chunk-5VMR4WBS.js";
 
 // src/browser/gpuPolicy.ts
 function resolveLocalBrowserGpuMode(browserGpuArg, envMode = process.env.PRODUCER_BROWSER_GPU_MODE) {
@@ -13,11 +17,16 @@ function resolveLocalBrowserGpuMode(browserGpuArg, envMode = process.env.PRODUCE
   return "auto";
 }
 async function resolveCaptureBrowserGpuMode(requestedMode, chromePath) {
-  const { resolveBrowserGpuMode } = await import("./src-3I3RH3V5.js");
+  const { resolveBrowserGpuMode } = await import("./src-VUJ2FUFK.js");
   return resolveBrowserGpuMode(requestedMode, { chromePath });
 }
+function resolveLocalWebGpu(browserGpuMode, requiresWebGpu) {
+  const gpuConfig = { browserGpuMode, allowSoftwareWebGpu: resolveConfig().allowSoftwareWebGpu };
+  return { gpuConfig, softwareWebGpu: usesSoftwareWebGpu(requiresWebGpu, gpuConfig) };
+}
 
 export {
   resolveLocalBrowserGpuMode,
-  resolveCaptureBrowserGpuMode
+  resolveCaptureBrowserGpuMode,
+  resolveLocalWebGpu
 };

package/dist/{chunk-LAOCA3MQ.js → chunk-A4Q7W4LV.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   runRenderSetupWorker,
   terminateProcessTree
-} from "./chunk-LCSMOLGX.js";
+} from "./chunk-BYSBRF24.js";
 
 // src/utils/orphanCleanup.ts
 import { execFileSync } from "child_process";
@@ -62,17 +62,19 @@ function processIdentity(pid) {
     return null;
   }
 }
+var holdsReusedPid = (parent, child) => parent.startedAt !== void 0 && child?.startedAt !== void 0 && parent.startedAt > child.startedAt;
 function recordsToAncestors(pid, records) {
   const byPid = new Map(records.map((record) => [record.pid, record]));
   const ancestors = [];
   const visited = /* @__PURE__ */ new Set([pid]);
   let current = pid;
   for (let depth = 0; depth < 64; depth++) {
-    const parent = byPid.get(current)?.parentPid;
+    const child = byPid.get(current);
+    const parent = child?.parentPid;
     if (parent === void 0 || parent <= 1 || visited.has(parent)) break;
     visited.add(parent);
     const ancestor = byPid.get(parent);
-    if (!ancestor) break;
+    if (!ancestor || holdsReusedPid(ancestor, child)) break;
     ancestors.push({ pid: ancestor.pid, identity: ancestor.identity });
     current = parent;
   }
@@ -92,11 +94,14 @@ function processAncestorSnapshot(pid) {
         ],
         { encoding: "utf8", timeout: 2e3, stdio: ["pipe", "pipe", "ignore"], windowsHide: true }
       );
-      const records2 = output2.split(/\r?\n/).map((line) => line.trim().split(/\s+/)).map(([processId, parentProcessId, creationDate]) => ({
-        pid: Number(processId),
-        parentPid: Number(parentProcessId),
-        identity: creationDate ? `windows:${creationDate}` : ""
-      })).filter(
+      const records2 = output2.split(/\r?\n/).map((line) => line.trim().split(/\s+/)).map(
+        ([processId, parentProcessId, creationDate]) => ({
+          pid: Number(processId),
+          parentPid: Number(parentProcessId),
+          identity: creationDate ? `windows:${creationDate}` : "",
+          startedAt: creationDate && /^\d+$/.test(creationDate) ? BigInt(creationDate) : void 0
+        })
+      ).filter(
         (record) => Number.isInteger(record.pid) && record.pid > 0 && Number.isInteger(record.parentPid) && record.parentPid > 0 && record.identity !== ""
       );
       return recordsToAncestors(pid, records2);

package/dist/{chunk-B6SMSALD.js → chunk-A53CBD24.js}

@@ -6,24 +6,24 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   serveStaticProjectHtml
-} from "./chunk-LQASVU3I.js";
+} from "./chunk-RVFEDAUV.js";
 import {
   resolveProject
-} from "./chunk-LJAU4TPS.js";
+} from "./chunk-KFKZ3ISO.js";
 import {
   AUDIT_SEEK_OPTIONS,
   installPageFunctionGuard,
   seekCompositionTimeline,
   waitForCompositionFonts,
   waitForRuntimeReady
-} from "./chunk-WSGY5CDQ.js";
+} from "./chunk-SLCFKB3Y.js";
 import {
   launchManagedBrowser,
   resolveManagedGpuMode
-} from "./chunk-OSUKETIH.js";
+} from "./chunk-5WADG7PR.js";
 import {
   resolveDiagnosticNavigationTimeoutMs
-} from "./chunk-TY6XOHEM.js";
+} from "./chunk-GZM2EFOE.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -34,7 +34,7 @@ import {
 import {
   printDeprecationNotice,
   withMeta
-} from "./chunk-JLKMWY2T.js";
+} from "./chunk-P6WH6QTV.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -707,7 +707,7 @@ async function collectTweenBoundaries(page) {
   });
 }
 async function bundleProjectHtml(projectDir) {
-  const { bundleToSingleHtml } = await import("./compiler-VTH2D3ID.js");
+  const { bundleToSingleHtml } = await import("./compiler-JZ4GNFMG.js");
   return bundleToSingleHtml(projectDir);
 }
 async function alignViewportToComposition(page, url) {
@@ -727,10 +727,15 @@ async function alignViewportToComposition(page, url) {
   });
 }
 async function runLayoutAudit(projectDir, opts) {
-  const { ensureBrowser } = await import("./manager-CT3D67CG.js");
+  const { ensureBrowser } = await import("./manager-BPSR6D3V.js");
   const puppeteer = await import("puppeteer-core");
-  const { buildChromeArgs } = await import("./src-3I3RH3V5.js");
-  const { assertWebGpuAdapterAvailable, compositionRequiresWebGpu, resolveLocalBrowserGpuMode } = await import("./gpuPolicy-LCBWVGEH.js");
+  const { buildChromeArgs } = await import("./src-VUJ2FUFK.js");
+  const {
+    assertWebGpuAdapterAvailable,
+    compositionRequiresWebGpu,
+    resolveLocalBrowserGpuMode,
+    resolveLocalWebGpu
+  } = await import("./gpuPolicy-NBJNWHYS.js");
   const html = await bundleProjectHtml(projectDir);
   const server = await serveStaticProjectHtml(
     projectDir,
@@ -743,12 +748,13 @@ async function runLayoutAudit(projectDir, opts) {
     const requestedGpuMode = resolveLocalBrowserGpuMode();
     const resolvedGpuMode = await resolveManagedGpuMode(requestedGpuMode, browser.executablePath);
     const requiresWebGpu = compositionRequiresWebGpu(html);
+    const { gpuConfig, softwareWebGpu } = resolveLocalWebGpu(resolvedGpuMode, requiresWebGpu);
     chromeBrowser = await launchManagedBrowser(puppeteer.default, {
       headless: true,
       executablePath: browser.executablePath,
       args: buildChromeArgs(
         { width: 1920, height: 1080, captureMode: "screenshot", requiresWebGpu },
-        { browserGpuMode: resolvedGpuMode }
+        gpuConfig
       )
     });
     const page = await chromeBrowser.newPage();
@@ -758,7 +764,7 @@ async function runLayoutAudit(projectDir, opts) {
       waitUntil: "domcontentloaded",
       timeout: resolveDiagnosticNavigationTimeoutMs()
     });
-    await assertWebGpuAdapterAvailable(page, requiresWebGpu);
+    await assertWebGpuAdapterAvailable(page, requiresWebGpu, softwareWebGpu);
     await alignViewportToComposition(page, server.url);
     await waitForRuntimeReady(page, opts.timeout);
     await waitForCompositionFonts(page, 750);

package/dist/{chunk-4PFZPP2N.js → chunk-A6S35NYA.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   runRenderSetupWorker
-} from "./chunk-LCSMOLGX.js";
+} from "./chunk-BYSBRF24.js";
 import {
   chromeMajorCeiling,
   exceedsChromeCeiling
@@ -30,6 +30,7 @@ import {
   writeFileSync
 } from "fs";
 import { homedir } from "os";
+import { debuglog } from "util";
 import { basename, dirname, join, relative } from "path";
 async function loadPuppeteerBrowsers() {
   try {
@@ -234,7 +235,7 @@ async function findFromHyperframesCache() {
   const match = installed.find(
     (b) => b.browser === Browser.CHROMEHEADLESSSHELL && b.buildId === managedChromeVersion() && b.platform === hostPlatform
   );
-  if (match && existsSync(match.executablePath)) {
+  if (match && isUsableExecutable(match.executablePath)) {
     return { result: { executablePath: match.executablePath, source: "cache" } };
   }
   if (match) {
@@ -301,7 +302,7 @@ function findFromPuppeteerCache() {
   for (const version of versions) {
     if (exceedsChromeCeiling(version, ceiling)) continue;
     const binary = join(PUPPETEER_CACHE_DIR, version, ...executable);
-    if (existsSync(binary)) {
+    if (isUsableExecutable(binary)) {
       return { executablePath: binary, source: "cache" };
     }
   }
@@ -345,14 +346,14 @@ async function findBrowser() {
   if (fromCache.result) return fromCache.result;
   if (fromCache.staleHyperframesCachePath) {
     console.warn(
-      `[browser] Cached binary missing at ${fromCache.staleHyperframesCachePath} \u2014 re-downloading...`
+      `[browser] Cached binary unusable (missing, empty or not a file) at ${fromCache.staleHyperframesCachePath} \u2014 re-downloading...`
     );
     try {
       return await withInstallLock(() => downloadBrowser());
     } catch (err) {
       const cause = normalizeErrorMessage(err);
       throw new Error(
-        `Cached Chrome binary was missing at ${fromCache.staleHyperframesCachePath}, and re-download failed: ${cause}
+        `Cached Chrome binary was unusable at ${fromCache.staleHyperframesCachePath}, and re-download failed: ${cause}
 Run \`hyperframes browser ensure --force\` to re-download.`
       );
     }
@@ -414,7 +415,7 @@ async function ensureBrowserInCurrentProcess(options) {
     if (fromCache.result) return fromCache.result;
     if (fromCache.staleHyperframesCachePath) {
       console.warn(
-        `[browser] Cached binary missing at ${fromCache.staleHyperframesCachePath} \u2014 re-downloading...`
+        `[browser] Cached binary unusable (missing, empty or not a file) at ${fromCache.staleHyperframesCachePath} \u2014 re-downloading...`
       );
       return withInstallLock(() => downloadBrowser(options));
     }
@@ -478,10 +479,11 @@ function browserPathHintForPlatform() {
   }
   return "/usr/bin/google-chrome";
 }
-function wrapDownloadFailureWithBrowserPathHint(cause) {
+function wrapDownloadFailureWithBrowserPathHint(cause, unzipLog) {
   const original = normalizeErrorMessage(cause);
+  const unzipErrors = unzipLog.length > 0 ? ` Unzip errors: ${unzipLog.join("; ")}` : "";
   const example = browserPathHintForPlatform();
-  const message = `Failed to download chrome-headless-shell ${managedChromeVersion()}: ${original}
+  const message = `Failed to install chrome-headless-shell ${managedChromeVersion()}: ${original}${unzipErrors}
 
 Point hyperframes at an already-installed Chrome/Chromium instead:
 
@@ -502,13 +504,27 @@ async function downloadBrowser(options) {
   removeInstallLeftovers();
   const stagingDir = join(CACHE_ROOT_DIR, `${STAGING_PREFIX}${randomUUID()}`);
   const clearStaging = () => rmSync(stagingDir, { recursive: true, force: true });
-  const runInstall = () => install({
-    cacheDir: stagingDir,
-    browser: Browser.CHROMEHEADLESSSHELL,
-    buildId: managedChromeVersion(),
-    platform,
-    downloadProgressCallback: options?.onProgress
-  });
+  let unzipLog = [];
+  const runInstall = () => {
+    unzipLog = [];
+    return install({
+      cacheDir: stagingDir,
+      browser: Browser.CHROMEHEADLESSSHELL,
+      buildId: managedChromeVersion(),
+      platform,
+      downloadProgressCallback: options?.onProgress,
+      logger: (prefix) => {
+        const debug = debuglog(prefix);
+        const isUnzip = prefix === "puppeteer:browsers:fileUtil";
+        if (!isUnzip && !debug.enabled) return void 0;
+        return (...args) => {
+          const line = args.join(" ");
+          if (isUnzip) unzipLog.push(line);
+          if (debug.enabled) debug(line);
+        };
+      }
+    });
+  };
   try {
     const staged = await installWithCorruptArchiveRecovery(
       runInstall,
@@ -517,13 +533,35 @@ async function downloadBrowser(options) {
         `[hyperframes] Downloaded browser archive was corrupt (${normalizeErrorMessage(err)}); re-downloading.`
       )
     );
+    assertExecutableUnpacked(stagingDir, staged.executablePath);
+    unzipLog = [];
     return { executablePath: moveStagedInstallIntoCache(stagingDir, staged), source: "download" };
   } catch (err) {
-    throw wrapDownloadFailureWithBrowserPathHint(err);
+    throw wrapDownloadFailureWithBrowserPathHint(err, unzipLog);
   } finally {
     clearStaging();
   }
 }
+function executableState(path) {
+  const stat = statSync(path, { throwIfNoEntry: false });
+  if (!stat) return "is missing";
+  if (!stat.isFile()) return "is not a file";
+  return stat.size > 0 ? "usable" : "is empty";
+}
+function isUsableExecutable(path) {
+  try {
+    return executableState(path) === "usable";
+  } catch {
+    return false;
+  }
+}
+function assertExecutableUnpacked(stagingDir, executablePath) {
+  const state = executableState(executablePath);
+  if (state === "usable") return;
+  throw new Error(
+    `the archive downloaded, but ${relative(stagingDir, executablePath)} ${state} after unzipping.`
+  );
+}
 function moveStagedInstallIntoCache(stagingDir, staged) {
   const target = join(CACHE_DIR, relative(stagingDir, staged.path));
   const aside = join(CACHE_ROOT_DIR, `${REPLACED_PREFIX}${randomUUID()}`);

package/dist/{chunk-JOTLPC6S.js → chunk-AUBOF2PN.js}

@@ -8,7 +8,7 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemManifest,
   fetchRegistryManifest
-} from "./chunk-QXPCARFE.js";
+} from "./chunk-I5KY7EZP.js";
 
 // src/registry/resolver.ts
 function defaultWarn(message) {

package/dist/{chunk-WCJGTLPF.js → chunk-BHVFTYSI.js}

@@ -52,6 +52,7 @@ function downloadFile(url, dest, options = {}) {
   return new Promise((resolve, reject) => {
     const follow = (u, hops = 0) => {
       let activeResponse;
+      let responseDiscarded = false;
       let responsePipelineStarted = false;
       let requestError;
       let request;
@@ -61,15 +62,15 @@ function downloadFile(url, dest, options = {}) {
           if (res.statusCode && REDIRECT_CODES.has(res.statusCode)) {
             const location = res.headers.location;
             if (location) {
+              responseDiscarded = true;
+              res.destroy();
               if (hops >= MAX_REDIRECTS) {
-                res.resume();
                 removePartialFile(tmp);
                 reject(
                   new Error(`Download failed: more than ${MAX_REDIRECTS} redirects from ${url}`)
                 );
                 return;
               }
-              res.resume();
               try {
                 follow(redirectTarget(location, u), hops + 1);
               } catch (error) {
@@ -80,7 +81,8 @@ function downloadFile(url, dest, options = {}) {
             }
           }
           if (res.statusCode !== 200) {
-            res.resume();
+            responseDiscarded = true;
+            res.destroy();
             removePartialFile(tmp);
             reject(new Error(`Download failed: HTTP ${res.statusCode}`));
             return;
@@ -107,6 +109,7 @@ function downloadFile(url, dest, options = {}) {
         request.destroy(new Error(`Download timed out after ${timeoutMs}ms`));
       });
       request.on("error", (err) => {
+        if (responseDiscarded) return;
         if (responsePipelineStarted) {
           requestError = err;
           activeResponse?.destroy(err);

package/dist/chunk-BSQ7XANM.js

@@ -0,0 +1,210 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+
+// ../parsers/dist/mediaDuration.js
+var COMPOSITION_ATTRIBUTES = Object.freeze({
+  start: "data-start",
+  duration: "data-duration",
+  trackIndex: "data-track-index",
+  derivedEnd: "data-end",
+  legacyTrack: "data-layer"
+});
+var CANONICAL_AUTHORED_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES.start,
+  COMPOSITION_ATTRIBUTES.duration,
+  COMPOSITION_ATTRIBUTES.trackIndex
+]);
+var DERIVED_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES.derivedEnd
+]);
+var LEGACY_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES.derivedEnd,
+  COMPOSITION_ATTRIBUTES.legacyTrack
+]);
+function parseNumeric(value) {
+  if (value == null || value.trim() === "") return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+var nonNegative = (raw) => {
+  const value = parseNumeric(raw);
+  return value !== null && value >= 0 ? value : null;
+};
+function readMediaOffsetSeconds(getAttr) {
+  return nonNegative(getAttr("data-playback-start")) ?? nonNegative(getAttr("data-media-start")) ?? 0;
+}
+var MIN_PLAYBACK_RATE = 0.1;
+var MAX_PLAYBACK_RATE = 10;
+function clampPlaybackRate(raw) {
+  return Number.isFinite(raw) && raw > 0 ? Math.max(MIN_PLAYBACK_RATE, Math.min(MAX_PLAYBACK_RATE, raw)) : 1;
+}
+function readPlaybackRate(getAttr, fallback = 1) {
+  const authored = Number.parseFloat(getAttr("data-playback-rate") ?? "");
+  return clampPlaybackRate(Number.isFinite(authored) && authored > 0 ? authored : fallback);
+}
+function readDataDurationSeconds(getAttr) {
+  const duration = parseNumeric(getAttr("data-duration"));
+  return duration !== null && duration > 0 ? duration : null;
+}
+function readAuthoredDurationSeconds(getAttr, startSeconds) {
+  const duration = readDataDurationSeconds(getAttr);
+  if (duration !== null) return duration;
+  const end = parseNumeric(getAttr("data-end"));
+  return end !== null ? end - startSeconds : null;
+}
+var DEFAULT_IMAGE_TIMELINE_DURATION_SECONDS = 3;
+function resolveNaturalDurationSeconds(sourceDurationSeconds, mediaStartSeconds, playbackRate) {
+  if (!Number.isFinite(sourceDurationSeconds)) return null;
+  const remaining = Math.max(0, sourceDurationSeconds - mediaStartSeconds);
+  return remaining / clampPlaybackRate(playbackRate);
+}
+function resolveMediaDuration(input) {
+  const { tag, authoredDurationSeconds, sourceDurationSeconds, mediaStartSeconds, playbackRate } = input;
+  if (authoredDurationSeconds !== null && authoredDurationSeconds > 0) {
+    return { seconds: authoredDurationSeconds, source: "authored" };
+  }
+  if (tag === "img") {
+    return { seconds: DEFAULT_IMAGE_TIMELINE_DURATION_SECONDS, source: "default" };
+  }
+  if (sourceDurationSeconds === null) {
+    return { seconds: null, source: "pending", reason: "source duration not yet probed" };
+  }
+  const seconds = resolveNaturalDurationSeconds(
+    sourceDurationSeconds,
+    mediaStartSeconds,
+    playbackRate
+  );
+  if (seconds === null) {
+    return { seconds: null, source: "pending", reason: "source reported a non-finite duration" };
+  }
+  return { seconds, source: "media" };
+}
+
+// ../parsers/dist/assets.js
+import { isAbsolute, relative, resolve } from "path";
+import { posix } from "path";
+function decodeWellFormedEscapes(path) {
+  return path.replace(/(?:%[0-9A-Fa-f]{2})+/g, (run) => {
+    try {
+      return decodeURIComponent(run);
+    } catch {
+      return run;
+    }
+  });
+}
+function splitUrlSuffix(urlValue) {
+  const queryIdx = urlValue.indexOf("?");
+  const hashIdx = urlValue.indexOf("#");
+  if (queryIdx < 0 && hashIdx < 0) return { basePath: urlValue, suffix: "" };
+  let cutIdx = urlValue.length;
+  if (queryIdx >= 0) cutIdx = Math.min(cutIdx, queryIdx);
+  if (hashIdx >= 0) cutIdx = Math.min(cutIdx, hashIdx);
+  return { basePath: urlValue.slice(0, cutIdx), suffix: urlValue.slice(cutIdx) };
+}
+function decodedUrlPath(url) {
+  return decodeWellFormedEscapes(splitUrlSuffix(url).basePath);
+}
+function encodeUrlPath(path) {
+  return encodeURIComponent(path).replace(/%2F/g, "/").replace(/['()]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function decodeCssEscapes(text) {
+  return text.replaceAll("\0", "\uFFFD").replace(
+    /\\(?:([0-9a-f]{1,6})(?:\r\n|[ \t\r\n\f])?|(\r\n|[\n\r\f])|([\s\S]))/gi,
+    (_escaped, hex, lineBreak, char) => {
+      if (hex === void 0) return lineBreak === void 0 ? char : "";
+      const code = Number.parseInt(hex, 16);
+      if (code === 0 || code > 1114111 || code >= 55296 && code <= 57343) return "\uFFFD";
+      return String.fromCodePoint(code);
+    }
+  );
+}
+var CSS_URL_RE = /\burl\(\s*(["']?)([^)"'\s](?:[^)"']*[^)"'\s])?)\1\s*\)/g;
+var PATH_ATTRS = ["src", "href"];
+function isNonRelativeUrl(val) {
+  return !val || val.startsWith("http://") || val.startsWith("https://") || val.startsWith("//") || val.startsWith("data:") || val.startsWith("#") || val.startsWith("/");
+}
+function isPathInside(childPath, parentPath) {
+  const absChild = resolve(childPath);
+  const absParent = resolve(parentPath);
+  if (absChild === absParent) return true;
+  const rel = relative(absParent, absChild);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+var { join, resolve: resolve2, dirname } = posix;
+var isAbsoluteOrSpecial = isNonRelativeUrl;
+function needsRewrite(val) {
+  return val.startsWith("../") || val === "..";
+}
+function rewriteAssetPath(compSrcPath, relativePath, assetExists) {
+  if (isAbsoluteOrSpecial(relativePath)) return relativePath;
+  const compDir = dirname(compSrcPath);
+  if (!compDir || compDir === ".") return relativePath;
+  const { basePath, suffix } = splitUrlSuffix(relativePath);
+  const slashed = basePath.replace(/\\/g, "/");
+  if (!slashed || slashed.startsWith("/")) return relativePath;
+  const filePath = decodeWellFormedEscapes(slashed);
+  const sibling = resolve2("/", join(compDir, filePath)).slice(1);
+  if (!needsRewrite(filePath) && (!assetExists || !assetExists(sibling))) return relativePath;
+  return encodeUrlPath(sibling) + suffix;
+}
+function rewriteAssetPaths(elements, compSrcPath, getAttr, setAttr, assetExists) {
+  for (const el of elements) {
+    for (const attr of PATH_ATTRS) {
+      const val = (getAttr(el, attr) || "").trim();
+      const rewritten = rewriteAssetPath(compSrcPath, val, assetExists);
+      if (rewritten !== val) {
+        setAttr(el, attr, rewritten);
+      }
+    }
+  }
+}
+function rewriteInlineStyleAssetUrls(elements, compSrcPath, getStyle, setStyle, assetExists) {
+  const compDir = dirname(compSrcPath);
+  if (!compDir || compDir === ".") return;
+  for (const el of elements) {
+    const style = getStyle(el);
+    if (!style) continue;
+    const rewritten = rewriteCssAssetUrls(style, compSrcPath, assetExists);
+    if (rewritten !== style) {
+      setStyle(el, rewritten);
+    }
+  }
+}
+function rewriteCssAssetUrls(cssText, compSrcPath, assetExists) {
+  if (!cssText) return cssText;
+  return cssText.replace(CSS_URL_RE, (full, quote, rawUrl) => {
+    const urlValue = (rawUrl || "").trim();
+    const rewritten = rewriteAssetPath(compSrcPath, urlValue, assetExists);
+    if (rewritten === urlValue) return full;
+    return `url(${quote || ""}${rewritten}${quote || ""})`;
+  });
+}
+
+export {
+  readMediaOffsetSeconds,
+  MIN_PLAYBACK_RATE,
+  MAX_PLAYBACK_RATE,
+  clampPlaybackRate,
+  readPlaybackRate,
+  readDataDurationSeconds,
+  readAuthoredDurationSeconds,
+  resolveNaturalDurationSeconds,
+  resolveMediaDuration,
+  decodeWellFormedEscapes,
+  splitUrlSuffix,
+  decodedUrlPath,
+  encodeUrlPath,
+  decodeCssEscapes,
+  CSS_URL_RE,
+  PATH_ATTRS,
+  isNonRelativeUrl,
+  isPathInside,
+  rewriteAssetPath,
+  rewriteAssetPaths,
+  rewriteInlineStyleAssetUrls,
+  rewriteCssAssetUrls
+};