kuinetic 0.1.3 → 0.2.0

package/dist/esm/chunk-JT4PZL3A.mjs

@@ -1,773 +0,0 @@
-// src/core/registry.ts
-var Registry = class {
-  primitives = /* @__PURE__ */ new Map();
-  presets = /* @__PURE__ */ new Map();
-  /** Sorted-name key → preset that renders that combination as one tested keyframe. */
-  combos = /* @__PURE__ */ new Map();
-  registerPrimitive(primitive) {
-    if (this.primitives.has(primitive.id)) {
-      throw new Error(`kuinetic: primitive "${primitive.id}" is already registered`);
-    }
-    this.primitives.set(primitive.id, namespaceTiming(primitive));
-    return this;
-  }
-  registerPreset(preset) {
-    if (this.presets.has(preset.name)) {
-      throw new Error(`kuinetic: effect "${preset.name}" is already registered`);
-    }
-    if (!this.primitives.has(preset.primitive)) {
-      throw new Error(
-        `kuinetic: effect "${preset.name}" references unknown primitive "${preset.primitive}"`
-      );
-    }
-    this.presets.set(preset.name, preset);
-    return this;
-  }
-  registerPresets(presets) {
-    for (const preset of presets) this.registerPreset(preset);
-    return this;
-  }
-  registerPrimitives(primitives) {
-    for (const primitive of primitives) this.registerPrimitive(primitive);
-    return this;
-  }
-  /**
-   * Declare that a set of effect names has a purpose-built single-keyframe implementation.
-   * Checked before channel conflict analysis, so `fade-up` + `blur-in` can resolve to the
-   * tested `fade-blur-up` rather than being rejected for both writing `opacity`.
-   */
-  registerCombo(names, presetName) {
-    this.combos.set(comboKey(names), presetName);
-    return this;
-  }
-  resolve(name) {
-    const preset = this.presets.get(name);
-    if (!preset) return void 0;
-    const primitive = this.primitives.get(preset.primitive);
-    return { preset, primitive };
-  }
-  findCombo(names) {
-    const comboName = this.combos.get(comboKey(names));
-    return comboName ? this.resolve(comboName) : void 0;
-  }
-  has(name) {
-    return this.presets.has(name);
-  }
-  /** All registered effect names, for docs generation and dev-mode "did you mean" hints. */
-  names() {
-    return [...this.presets.keys()].sort((a, b) => a.localeCompare(b));
-  }
-  getPrimitive(id) {
-    return this.primitives.get(id);
-  }
-};
-var TIMING_PARAMS = ["duration", "delay", "ease"];
-function timingProperty(primitiveId, name) {
-  return `--kui-${primitiveId}-${name}`;
-}
-function namespaceTiming(primitive) {
-  const parameters = { ...primitive.parameters };
-  for (const name of TIMING_PARAMS) {
-    const spec = parameters[name];
-    if (spec) parameters[name] = { ...spec, cssProperty: timingProperty(primitive.id, name) };
-  }
-  return { ...primitive, parameters };
-}
-function comboKey(names) {
-  return [...names].sort((a, b) => a.localeCompare(b)).join("+");
-}
-function suggest(name, candidates) {
-  let best;
-  let bestScore = Infinity;
-  for (const candidate of candidates) {
-    const score = distance(name, candidate);
-    if (score < bestScore) {
-      bestScore = score;
-      best = candidate;
-    }
-  }
-  return bestScore <= Math.max(2, Math.floor(name.length / 3)) ? best : void 0;
-}
-function distance(a, b) {
-  const rows = a.length + 1;
-  const cols = b.length + 1;
-  let prev = Array.from({ length: cols }, (_, i) => i);
-  for (let i = 1; i < rows; i++) {
-    const curr = [i, ...Array(cols - 1).fill(0)];
-    for (let j = 1; j < cols; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
-    }
-    prev = curr;
-  }
-  return prev[cols - 1];
-}
-
-// src/core/types.ts
-var CHANNEL = {
-  opacity: "opacity",
-  translate: "translate",
-  scale: "scale",
-  rotate: "rotate",
-  filter: "filter",
-  clip: "clip",
-  background: "background",
-  color: "color",
-  stroke: "stroke",
-  text: "text",
-  /**
-   * Skew is the one transform CSS never gave an independent property to — there is no `skew:`
-   * beside `translate:`/`rotate:`/`scale:`, so it can only be written through the `transform`
-   * shorthand. That makes it its own channel: anything writing `transform` clobbers the whole
-   * shorthand, so every primitive that does is on this channel, whatever the transform is for.
-   * `scroll-skew` is one member; `flip-face` (`effects/three-d`) and `flip-3d`
-   * (`effects/catalog/core`, the `flip-in-*`/`flip-out-*` family) are the other two — both need
-   * the `perspective()` transform *function* for an element to have depth on itself, which
-   * likewise only exists inside `transform`.
-   */
-  skew: "skew"
-};
-function inertInstance(destroy = () => {
-}) {
-  return {
-    activate() {
-    },
-    cancel() {
-    },
-    finish() {
-    },
-    finished: Promise.resolve(),
-    destroy
-  };
-}
-
-// src/core/params.ts
-var DANGEROUS = /[;<]|\/\*|url\s*\(|expression\s*\(|@import|image-set\s*\(/i;
-var ABSOLUTE_OR_PROTOCOL_RELATIVE = /^(?:[a-z][a-z0-9+.-]*:|[/\\]{2})/i;
-var MAX_VALUE_LENGTH = 200;
-var NUM = String.raw`-?(?:\d+(?:\.\d+)?|\.\d+)`;
-var LENGTH_UNITS = "px|rem|em|vh|vw|vmin|vmax|ch|ex|cm|mm|in|pt|pc|q|%";
-var PATTERNS = {
-  length: new RegExp(`^(?:0|${NUM}(?:${LENGTH_UNITS}))$`, "i"),
-  time: new RegExp(`^${NUM}(?:ms|s)$`, "i"),
-  number: new RegExp(`^${NUM}$`),
-  percentage: new RegExp(`^${NUM}%$`),
-  angle: new RegExp(`^${NUM}(?:deg|rad|turn|grad)$`, "i")
-};
-var HEX_COLOR = /^#[0-9a-f]{3,8}$/i;
-var COLOR_FUNCTIONS = /^(?:rgba?|hsla?|okl(?:ch|ab)|l(?:ch|ab)|color)\([^()]*\)$/i;
-var COLOR_KEYWORD = /^[a-z]+$/i;
-var EASING_KEYWORD = /^(?:linear|ease|step-start|step-end|spring|bounce|[a-z]+-(?:in|out|in-out))$/i;
-var EASING_FUNCTION = /^(?:cubic-bezier|steps|linear)\([^()]*\)$/i;
-var CALC_TYPES = /* @__PURE__ */ new Set(["length", "percentage", "number"]);
-var CALC_CHARACTER = /^[\d.\s+\-*/%a-z,]$/i;
-var CUSTOM_PROPERTY_NAME = /^--[\w-]+$/;
-function validate(raw, spec) {
-  const value = raw.trim();
-  const rejection = screen(value, spec);
-  if (rejection) return rejection;
-  if (spec.type === "keyword") return checkKeyword(value, spec);
-  if (spec.type === "text") return { value, ok: true };
-  if (isAcceptable(value, spec.type)) return checkNumericConstraints(value, spec);
-  return reject(spec, `not a valid ${spec.type}`);
-}
-function screen(value, spec) {
-  if (!value) return reject(spec, "empty value");
-  if (value.length > MAX_VALUE_LENGTH) {
-    return reject(spec, `value exceeds ${MAX_VALUE_LENGTH} characters`);
-  }
-  if (DANGEROUS.test(value)) return reject(spec, "value contains disallowed CSS syntax");
-  return null;
-}
-function isAcceptable(value, type) {
-  if (type === "color") return isColor(value);
-  if (type === "easing") return EASING_KEYWORD.test(value) || EASING_FUNCTION.test(value);
-  const pattern = PATTERNS[type];
-  if (!pattern) return false;
-  if (pattern.test(value)) return true;
-  return CALC_TYPES.has(type) && isSafeCalc(value) && isWellFormedCalc(value);
-}
-function isColor(value) {
-  return HEX_COLOR.test(value) || COLOR_FUNCTIONS.test(value) || COLOR_KEYWORD.test(value);
-}
-function checkKeyword(value, spec) {
-  if (spec.values?.includes(value)) return { value, ok: true };
-  return reject(spec, `expected one of ${spec.values?.join(", ") ?? "(none declared)"}`);
-}
-function isSameOriginPath(value) {
-  return !ABSOLUTE_OR_PROTOCOL_RELATIVE.test(value);
-}
-function checkNumericConstraints(value, spec) {
-  if (spec.type !== "number") return { value, ok: true };
-  const numeric = Number(value);
-  if (spec.finite && !Number.isFinite(numeric)) return reject(spec, "expected a finite number");
-  if (spec.integer && !Number.isInteger(numeric)) return reject(spec, "expected an integer");
-  if (spec.minimum !== void 0 && numeric < spec.minimum) {
-    return reject(spec, `expected at least ${spec.minimum}`);
-  }
-  if (spec.maximum !== void 0 && numeric > spec.maximum) {
-    return reject(spec, `expected at most ${spec.maximum}`);
-  }
-  return { value, ok: true };
-}
-function reject(spec, reason) {
-  return { value: spec.default, ok: false, reason };
-}
-function isSafeCalc(value) {
-  if (!value.startsWith("calc(") || !value.endsWith(")")) return false;
-  const end = value.length - 1;
-  let index = "calc(".length;
-  while (index < end) {
-    index = nextCalcToken(value, index, end);
-    if (index < 0) return false;
-  }
-  return true;
-}
-function nextCalcToken(value, index, end) {
-  if (value.startsWith("var(", index)) return consumeVar(value, index, end);
-  return CALC_CHARACTER.test(value[index]) ? index + 1 : -1;
-}
-function consumeVar(value, start, end) {
-  const close = value.indexOf(")", start + "var(".length);
-  if (close < 0 || close >= end) return -1;
-  const name = value.slice(start + "var(".length, close);
-  return CUSTOM_PROPERTY_NAME.test(name) ? close + 1 : -1;
-}
-function isWellFormedCalc(value) {
-  const body = value.slice("calc(".length, -1).trim();
-  return body !== "" && !/[+\-*/]$/.test(body);
-}
-function resolveParams(authored, schema, warn) {
-  const out = {};
-  for (const [key, raw] of Object.entries(authored)) {
-    const spec = Object.hasOwn(schema, key) ? schema[key] : void 0;
-    if (!spec) {
-      warn(`unknown parameter "${key}" (known: ${Object.keys(schema).join(", ") || "none"})`);
-      continue;
-    }
-    if (spec.type === "text") continue;
-    const result = validate(raw, spec);
-    if (result.ok) out[spec.cssProperty] = result.value;
-    else warn(`parameter "${key}": ${result.reason} \u2014 got "${raw}", using default "${spec.default}"`);
-  }
-  return out;
-}
-
-// src/core/js-params.ts
-var ABSOLUTE_BASIS = {
-  viewportWidth: 0,
-  viewportHeight: 0,
-  percentBasis: 0,
-  fontSize: 16,
-  rootFontSize: 16
-};
-var STATIC_UNITS = {
-  px: 1,
-  cm: 96 / 2.54,
-  mm: 96 / 25.4,
-  q: 96 / 101.6,
-  in: 96,
-  pt: 96 / 72,
-  pc: 16
-};
-var BASIS_UNITS = {
-  vh: (b) => b.viewportHeight / 100,
-  vw: (b) => b.viewportWidth / 100,
-  vmin: (b) => Math.min(b.viewportWidth, b.viewportHeight) / 100,
-  vmax: (b) => Math.max(b.viewportWidth, b.viewportHeight) / 100,
-  "%": (b) => b.percentBasis / 100,
-  em: (b) => b.fontSize,
-  rem: (b) => b.rootFontSize,
-  ch: (b) => b.fontSize * 0.5,
-  ex: (b) => b.fontSize * 0.5
-};
-var NUMBER_WITH_UNIT = /^(-?(?:\d+(?:\.\d+)?|\.\d+))([a-z%]*)$/i;
-function readParams(authored, schema, warn) {
-  const out = {};
-  for (const [name, spec] of Object.entries(schema)) out[name] = spec.default;
-  for (const [name, raw] of Object.entries(authored)) {
-    const spec = Object.hasOwn(schema, name) ? schema[name] : void 0;
-    if (!spec) {
-      warn(`unknown parameter "${name}" (known: ${Object.keys(schema).join(", ") || "none"})`);
-      continue;
-    }
-    const result = validate(raw, spec);
-    out[name] = result.value;
-    if (!result.ok) {
-      warn(`parameter "${name}": ${result.reason} \u2014 got "${raw}", using default "${spec.default}"`);
-    }
-  }
-  return out;
-}
-function toMilliseconds(value, fallback = 0) {
-  const parts = NUMBER_WITH_UNIT.exec(value.trim());
-  if (!parts) return fallback;
-  const amount = Number.parseFloat(parts[1]);
-  const unit = parts[2].toLowerCase();
-  if (unit === "ms") return amount;
-  if (unit === "s") return amount * 1e3;
-  return fallback;
-}
-function toPixels(value, basis, fallback = 0) {
-  const parts = NUMBER_WITH_UNIT.exec(value.trim());
-  if (!parts) return fallback;
-  const amount = Number.parseFloat(parts[1]);
-  const unit = parts[2].toLowerCase();
-  if (unit === "") return amount === 0 ? 0 : fallback;
-  const staticFactor = STATIC_UNITS[unit];
-  if (staticFactor !== void 0) return amount * staticFactor;
-  const basisFactor = BASIS_UNITS[unit];
-  return basisFactor ? amount * basisFactor(basis) : fallback;
-}
-function toNumber(value, fallback = 0) {
-  const parts = NUMBER_WITH_UNIT.exec(value.trim());
-  if (!parts) return fallback;
-  const amount = Number.parseFloat(parts[1]);
-  const unit = parts[2];
-  if (unit === "") return amount;
-  if (unit === "%") return amount / 100;
-  return fallback;
-}
-var EASING_SPEC = { type: "easing", default: "", cssProperty: "--kui-ease" };
-function timingMs(raw, label, warn) {
-  if (raw === void 0) return void 0;
-  const ms = toMilliseconds(raw, Number.NaN);
-  if (Number.isFinite(ms)) return ms;
-  warn(`${label} "${raw}" is not a valid time \u2014 ignored`);
-  return void 0;
-}
-function timingEasing(raw, warn) {
-  if (raw === void 0) return void 0;
-  const result = validate(raw, EASING_SPEC);
-  if (result.ok) return result.value;
-  warn(`easing "${raw}": ${result.reason} \u2014 ignored`);
-  return void 0;
-}
-function readEffectTiming(spec, warn) {
-  return {
-    durationMs: timingMs(spec.duration, "duration", warn),
-    delayMs: timingMs(spec.delay, "delay", warn),
-    easing: timingEasing(spec.easing, warn)
-  };
-}
-function effectDurationMs(params, fallback) {
-  return params.timing.durationMs ?? params.ms("duration", fallback);
-}
-function createParams(values, timing = {}) {
-  return {
-    text: (name, fallback = "") => values[name] ?? fallback,
-    ms: (name, fallback = 0) => toMilliseconds(values[name] ?? "", fallback),
-    num: (name, fallback = 0) => toNumber(values[name] ?? "", fallback),
-    is: (name, value = "true") => (values[name] ?? "") === value,
-    timing
-  };
-}
-function readEffectParams(authored, schema, warn, timing = {}) {
-  return createParams(readParams(authored, schema, warn), timing);
-}
-
-// src/core/scroll-scheduler.ts
-function defaultDeps() {
-  const raf = globalThis.requestAnimationFrame;
-  if (typeof raf !== "function") {
-    return {
-      requestFrame: (callback) => globalThis.setTimeout(callback, 16),
-      cancelFrame: (handle) => globalThis.clearTimeout(handle)
-    };
-  }
-  return {
-    requestFrame: (callback) => raf(callback),
-    cancelFrame: (handle) => globalThis.cancelAnimationFrame(handle)
-  };
-}
-function createScrollScheduler(deps = defaultDeps()) {
-  const entries = /* @__PURE__ */ new Map();
-  let epoch = 0;
-  let pending = null;
-  function schedule(entry) {
-    if (entry) entry.dirty = true;
-    else for (const other of entries.values()) other.dirty = true;
-    if (pending !== null) return;
-    pending = deps.requestFrame(runFrame);
-  }
-  function runFrame() {
-    pending = null;
-    for (const entry of entries.values()) {
-      if (!entry.dirty || entry.subscribers.size === 0) continue;
-      entry.dirty = false;
-      const frame = { metrics: entry.root.metrics(), epoch };
-      for (const subscriber of [...entry.subscribers]) subscriber(frame);
-    }
-  }
-  function attach(root) {
-    const existing = entries.get(root.key);
-    if (existing) return existing;
-    const entry = { root, subscribers: /* @__PURE__ */ new Set(), detach: [], dirty: false };
-    entry.detach.push(root.onScroll(() => schedule(entry)));
-    entry.detach.push(
-      root.onResize(() => {
-        epoch++;
-        schedule();
-      })
-    );
-    entries.set(root.key, entry);
-    return entry;
-  }
-  function release(entry) {
-    if (entry.subscribers.size > 0) return;
-    for (const detach of entry.detach) detach();
-    entries.delete(entry.root.key);
-  }
-  return {
-    subscribe(root, onFrame) {
-      const entry = attach(root);
-      entry.subscribers.add(onFrame);
-      schedule(entry);
-      return () => {
-        entry.subscribers.delete(onFrame);
-        release(entry);
-      };
-    },
-    invalidate() {
-      epoch++;
-      schedule();
-    },
-    rootCount: () => entries.size,
-    destroy() {
-      if (pending !== null) deps.cancelFrame(pending);
-      pending = null;
-      for (const entry of entries.values()) {
-        entry.subscribers.clear();
-        for (const detach of entry.detach) detach();
-      }
-      entries.clear();
-    }
-  };
-}
-function windowScrollRoot(win) {
-  return {
-    key: "window",
-    metrics: () => ({
-      scrollTop: win.scrollY,
-      scrollLeft: win.scrollX,
-      viewportWidth: win.innerWidth,
-      viewportHeight: win.innerHeight,
-      viewportTop: 0,
-      viewportLeft: 0
-    }),
-    onScroll: (handler) => listen(win, "scroll", handler),
-    /*
-     * The document's own height counts as a resize, not just the window's.
-     *
-     * `elementScrollRoot` has observed its element's size since it was written, for the reason
-     * stated three doc comments down: "images loading, fonts swapping, a container changing size,
-     * or content being inserted". Every one of those applies at least as strongly to the page
-     * itself, and the page root was the one that only listened for `window.resize` — so on any
-     * document with lazy-loaded media below the fold, every cached content offset silently drifted
-     * by however much the page grew after it was measured, with no epoch bump to correct it.
-     *
-     * Measured on `demo/scroll.html` (32,000px of lazy screenshots): the horizontal track's stage
-     * moved ~840px between page load and reaching it, which is a third of that effect's whole
-     * scroll range. Nothing was wrong with the maths; the number it was doing the maths on was
-     * taken before forty images existed.
-     */
-    onResize: (handler) => observeSize(win.document.documentElement, win, handler)
-  };
-}
-function elementScrollRoot(el, win) {
-  return {
-    key: `el:${rootId(el)}`,
-    metrics: () => {
-      const rect = el.getBoundingClientRect();
-      return {
-        scrollTop: el.scrollTop,
-        scrollLeft: el.scrollLeft,
-        viewportWidth: el.clientWidth,
-        viewportHeight: el.clientHeight,
-        viewportTop: rect.top,
-        viewportLeft: rect.left
-      };
-    },
-    onScroll: (handler) => listen(el, "scroll", handler),
-    // Window resize alone misses the cases that actually invalidate a nested scroller: images
-    // loading, fonts swapping, a container changing size, or content being inserted.
-    onResize: (handler) => observeSize(el, win, handler)
-  };
-}
-function listen(target, type, handler) {
-  target.addEventListener(type, handler, { passive: true });
-  return () => target.removeEventListener(type, handler);
-}
-function observeSize(el, win, handler) {
-  const stopWindow = listen(win, "resize", handler);
-  if (typeof ResizeObserver === "undefined") return stopWindow;
-  const observer = new ResizeObserver(handler);
-  observer.observe(el);
-  return () => {
-    stopWindow();
-    observer.disconnect();
-  };
-}
-var nextRootId = 0;
-var rootIds = /* @__PURE__ */ new WeakMap();
-function rootId(el) {
-  const existing = rootIds.get(el);
-  if (existing) return existing;
-  const id = String(++nextRootId);
-  rootIds.set(el, id);
-  return id;
-}
-function createRootResolver(options) {
-  const { win } = options;
-  const isScrollable = options.isScrollable ?? defaultIsScrollable(win);
-  const windowRoot = windowScrollRoot(win);
-  return (el) => {
-    for (let node = el.parentElement; node; node = node.parentElement) {
-      if (isScrollable(node)) return elementScrollRoot(node, win);
-    }
-    return windowRoot;
-  };
-}
-var SCROLLABLE_OVERFLOW = /* @__PURE__ */ new Set(["auto", "scroll", "overlay"]);
-function defaultIsScrollable(win) {
-  return (el) => {
-    const style = win.getComputedStyle(el);
-    const vertical = SCROLLABLE_OVERFLOW.has(style.overflowY) && el.scrollHeight > el.clientHeight;
-    const horizontal = SCROLLABLE_OVERFLOW.has(style.overflowX) && el.scrollWidth > el.clientWidth;
-    return vertical || horizontal;
-  };
-}
-function clamp01(value) {
-  if (Number.isNaN(value)) return 0;
-  return Math.min(1, Math.max(0, value));
-}
-function createMeasureCache(measure) {
-  let cachedEpoch = -1;
-  let cached;
-  return {
-    read(epoch) {
-      if (cachedEpoch !== epoch || cached === void 0) {
-        cached = measure();
-        cachedEpoch = epoch;
-      }
-      return cached;
-    },
-    clear() {
-      cachedEpoch = -1;
-      cached = void 0;
-    }
-  };
-}
-
-// src/core/instances.ts
-function animationsOf(el) {
-  const getAnimations = el.getAnimations;
-  return typeof getAnimations === "function" ? getAnimations.call(el) : [];
-}
-function ownedAnimationsOf(el, names) {
-  return animationsOf(el).filter((animation) => {
-    const name = animation.animationName;
-    return typeof name === "string" && names.has(name);
-  });
-}
-function flushComputedAnimationName(el) {
-  return getComputedStyle(el).animationName;
-}
-function restartCssAnimation(el, ledger) {
-  const name = el.style.getPropertyValue("animation-name");
-  ledger.set("animation-name", "none");
-  flushComputedAnimationName(el);
-  ledger.set("animation-name", name);
-}
-function createCssInstance(el, ledger, animationNames, scrubbed = false) {
-  const ownedNames = new Set(animationNames);
-  let settle;
-  let finished = new Promise((resolve) => {
-    settle = resolve;
-  });
-  let activatedBefore = false;
-  function watch(animations) {
-    if (animations.length === 0) {
-      settle?.();
-      return;
-    }
-    void Promise.all(animations.map((a) => a.finished.catch(() => void 0))).then(() => settle?.());
-  }
-  return {
-    activate() {
-      finished = new Promise((resolve) => {
-        settle = resolve;
-      });
-      if (scrubbed) {
-        settle?.();
-        return;
-      }
-      let animations = ownedAnimationsOf(el, ownedNames);
-      if (!activatedBefore) {
-        restartCssAnimation(el, ledger);
-        ledger.set("animation-play-state", "running");
-        animations = ownedAnimationsOf(el, ownedNames);
-      } else {
-        const stale = animations.filter((a) => a.playState === "finished");
-        if (stale.length > 0) {
-          for (const animation of stale) animation.reverse();
-        } else {
-          ledger.set("animation-play-state", "running");
-        }
-      }
-      activatedBefore = true;
-      watch(animations);
-    },
-    cancel() {
-      for (const animation of ownedAnimationsOf(el, ownedNames)) animation.cancel();
-      settle?.();
-    },
-    finish() {
-      for (const animation of ownedAnimationsOf(el, ownedNames)) animation.finish();
-      settle?.();
-    },
-    get finished() {
-      return finished;
-    },
-    destroy() {
-      settle?.();
-    }
-  };
-}
-function continuousSetup(cleanup) {
-  return { cleanup, continuous: true };
-}
-function cleanupOf(result) {
-  if (result === void 0) return void 0;
-  return typeof result === "function" ? result : result.cleanup;
-}
-function deferredInstance(setup) {
-  let running;
-  let settle;
-  let finished = Promise.resolve();
-  const teardown = () => {
-    cleanupOf(running)?.();
-    running = void 0;
-    settle?.();
-  };
-  return createJsInstance({
-    activate() {
-      running = setup();
-      if (typeof running === "function" || "continuous" in running) return;
-      const work = running.finished;
-      finished = new Promise((resolve) => {
-        settle = resolve;
-      });
-      void work.then(() => settle?.());
-    },
-    cancel: teardown,
-    finish() {
-      if (typeof running === "object" && "finish" in running) running.finish?.();
-      settle?.();
-    },
-    destroy: teardown,
-    finished: () => finished,
-    // Only an explicit marker counts. A bare `Cleanup` deliberately does not — see
-    // `ContinuousSetup` above for why the two cannot be told apart by shape.
-    continuous: () => typeof running === "object" && "continuous" in running
-  });
-}
-function deferPrepare(setup) {
-  return (...args) => deferredInstance(() => setup(...args));
-}
-function createJsInstance(hooks) {
-  let active = false;
-  return {
-    activate() {
-      if (active) return;
-      hooks.activate();
-      active = true;
-    },
-    cancel() {
-      hooks.cancel?.();
-      active = false;
-    },
-    finish() {
-      hooks.finish?.();
-    },
-    get finished() {
-      return hooks.finished?.() ?? Promise.resolve();
-    },
-    get continuous() {
-      return hooks.continuous?.() ?? false;
-    },
-    destroy() {
-      active = false;
-      hooks.destroy();
-    }
-  };
-}
-
-// src/core/owned-styles.ts
-function createStyleLedger(el) {
-  const style = el.style;
-  const previous = /* @__PURE__ */ new Map();
-  const authoredStyleAttribute = el.hasAttribute("style");
-  function remember(property) {
-    if (previous.has(property)) return;
-    const existing = style.getPropertyValue(property);
-    previous.set(property, existing === "" ? void 0 : existing);
-  }
-  return {
-    set(property, value) {
-      remember(property);
-      style.setProperty(property, value);
-    },
-    claim: remember,
-    restore() {
-      for (const [property, value] of previous) {
-        if (value === void 0) style.removeProperty(property);
-        else style.setProperty(property, value);
-      }
-      previous.clear();
-      if (!authoredStyleAttribute && style.length === 0 && !el.getAttribute("style"))
-        el.removeAttribute("style");
-    },
-    owned: () => [...previous.keys()]
-  };
-}
-function createAttributeLedger(el) {
-  const previous = /* @__PURE__ */ new Map();
-  return {
-    set(name, value) {
-      if (!previous.has(name)) previous.set(name, el.getAttribute(name));
-      el.setAttribute(name, value);
-    },
-    restore() {
-      for (const [name, value] of previous) {
-        if (value === null) el.removeAttribute(name);
-        else el.setAttribute(name, value);
-      }
-      previous.clear();
-    }
-  };
-}
-
-export {
-  isSameOriginPath,
-  resolveParams,
-  Registry,
-  timingProperty,
-  suggest,
-  ABSOLUTE_BASIS,
-  toPixels,
-  readEffectTiming,
-  effectDurationMs,
-  readEffectParams,
-  createScrollScheduler,
-  createRootResolver,
-  clamp01,
-  createMeasureCache,
-  createCssInstance,
-  continuousSetup,
-  deferPrepare,
-  createStyleLedger,
-  createAttributeLedger,
-  CHANNEL,
-  inertInstance
-};