kuinetic 0.1.0

package/dist/esm/chunk-LWS4OSLX.mjs

@@ -0,0 +1,730 @@
+// 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"
+};
+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|[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),
+    onResize: (handler) => listen(win, "resize", 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) {
+  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;
+      });
+      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 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") return;
+      const work = running.finished;
+      finished = new Promise((resolve) => {
+        settle = resolve;
+      });
+      void work.then(() => settle?.());
+    },
+    cancel: teardown,
+    finish() {
+      if (typeof running === "object") running.finish?.();
+      settle?.();
+    },
+    destroy: teardown,
+    finished: () => finished
+  });
+}
+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();
+    },
+    destroy() {
+      active = false;
+      hooks.destroy();
+    }
+  };
+}
+
+// src/core/owned-styles.ts
+function createStyleLedger(el) {
+  const style = el.style;
+  const previous = /* @__PURE__ */ new Map();
+  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();
+    },
+    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,
+  deferPrepare,
+  createStyleLedger,
+  createAttributeLedger,
+  CHANNEL,
+  inertInstance
+};