@buoy-gg/shared-ui 7.0.41 → 7.0.43

package/lib/module/dataViewer/objectDiff.js

@@ -1,297 +1 @@
-"use strict";
-
-/**
- * objectDiff — the bounded, cycle-safe diff KERNEL the dataViewer never had.
- *
- * Every diff consumer so far either hand-rolled a private summary helper or
- * fed whole values into the render-layer viewers (which compute eagerly, have
- * no cycle guards, and mis-compare rich types — TreeDiffViewer treats two
- * different Dates/Maps/Sets as EQUAL because they have zero own keys).
- *
- * This kernel is for VERDICTS and BADGES, not rendering:
- * - correct equality for Date / RegExp / Map / Set / BigInt / NaN /
- *   TypedArray / URL / Error, and `undefined`-value vs absent-key
- * - WeakSet cycle guard (a revisited pair reports unequal-safe truncation,
- *   never a stack overflow)
- * - hard depth + node budgets with an explicit `truncated` flag; when the
- *   budget runs out a subtree is reported as CHANGED (a false "changed" is
- *   recoverable — a false "unchanged" hides a real difference, the worst
- *   failure mode for a restore preview)
- *
- * `toDiffable` is the companion RENDER normalizer: it converts rich types to
- * plain-JSON stand-ins so the existing viewers (which only handle plain JSON
- * faithfully) never see a Date/Map/Set/BigInt/cycle at all.
- */
-
-function isPlainObjectLike(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const proto = Object.getPrototypeOf(v);
-  return proto === Object.prototype || proto === null;
-}
-function isTypedArray(v) {
-  return ArrayBuffer.isView(v) && !(v instanceof DataView);
-}
-
-/**
- * Bounded deep equality. Returns false on budget exhaustion (conservative:
- * report changed rather than hide a change) and marks the budget truncated.
- */
-export function boundedDeepEqual(a, b, options) {
-  const budget = {
-    nodes: options?.maxNodes ?? 2000,
-    truncated: false
-  };
-  return deepEqual(a, b, options?.maxDepth ?? 8, budget, new WeakSet());
-}
-function deepEqual(a, b, depth, budget, seen) {
-  if (budget.nodes-- <= 0) {
-    budget.truncated = true;
-    return false;
-  }
-  // NaN-equal, -0-distinct — Object.is has the right scalar semantics.
-  if (Object.is(a, b)) return true;
-  if (typeof a !== typeof b) return false;
-  if (typeof a !== "object" || a === null || b === null) {
-    // Distinct functions: treated as EQUAL — providers strip/preserve them
-    // and reference inequality across a serialization boundary is pure noise.
-    return typeof a === "function" && typeof b === "function";
-  }
-
-  // Rich types the render-layer viewers get wrong:
-  if (a instanceof Date || b instanceof Date) {
-    return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
-  }
-  if (a instanceof RegExp || b instanceof RegExp) {
-    return a instanceof RegExp && b instanceof RegExp && a.source === b.source && a.flags === b.flags;
-  }
-  if (a instanceof Error || b instanceof Error) {
-    return a instanceof Error && b instanceof Error && a.name === b.name && a.message === b.message;
-  }
-  if (typeof URL !== "undefined" && (a instanceof URL || b instanceof URL)) {
-    return a instanceof URL && b instanceof URL && a.href === b.href;
-  }
-  if (isTypedArray(a) || isTypedArray(b)) {
-    if (!isTypedArray(a) || !isTypedArray(b)) return false;
-    if (a.constructor !== b.constructor || a.byteLength !== b.byteLength) {
-      return false;
-    }
-    const ua = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
-    const ub = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
-    for (let i = 0; i < ua.length; i++) if (ua[i] !== ub[i]) return false;
-    return true;
-  }
-  if (depth <= 0) {
-    budget.truncated = true;
-    return false;
-  }
-  // Cycle guard: a revisited left-side object ends the walk for this branch.
-  // Reporting unequal here is the conservative direction.
-  if (seen.has(a)) {
-    budget.truncated = true;
-    return false;
-  }
-  seen.add(a);
-  if (a instanceof Map || b instanceof Map) {
-    if (!(a instanceof Map) || !(b instanceof Map) || a.size !== b.size) {
-      return false;
-    }
-    // Insertion-order comparison — superjson round-trips preserve it, and
-    // order-insensitive matching with object keys is quadratic.
-    const ea = Array.from(a.entries());
-    const eb = Array.from(b.entries());
-    for (let i = 0; i < ea.length; i++) {
-      if (!deepEqual(ea[i][0], eb[i][0], depth - 1, budget, seen)) return false;
-      if (!deepEqual(ea[i][1], eb[i][1], depth - 1, budget, seen)) return false;
-    }
-    return true;
-  }
-  if (a instanceof Set || b instanceof Set) {
-    if (!(a instanceof Set) || !(b instanceof Set) || a.size !== b.size) {
-      return false;
-    }
-    const va = Array.from(a.values());
-    const vb = Array.from(b.values());
-    for (let i = 0; i < va.length; i++) {
-      if (!deepEqual(va[i], vb[i], depth - 1, budget, seen)) return false;
-    }
-    return true;
-  }
-  if (Array.isArray(a) || Array.isArray(b)) {
-    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
-      return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-      if (!deepEqual(a[i], b[i], depth - 1, budget, seen)) return false;
-    }
-    return true;
-  }
-  const ka = Object.keys(a);
-  const kb = Object.keys(b);
-  if (ka.length !== kb.length) return false;
-  for (const k of ka) {
-    if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
-    if (!deepEqual(a[k], b[k], depth - 1, budget, seen)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/**
- * Top-level key diff of two values with bounded deep equality per key.
- * Non-object inputs degrade to a single implicit "value" comparison.
- */
-export function objectDiff(oldValue, newValue, options) {
-  const maxDepth = options?.maxDepth ?? 8;
-  const budget = {
-    nodes: options?.maxNodes ?? 2000,
-    truncated: false
-  };
-  const oldIsObj = isPlainObjectLike(oldValue);
-  const newIsObj = isPlainObjectLike(newValue);
-  if (!oldIsObj || !newIsObj) {
-    const equal = deepEqual(oldValue, newValue, maxDepth, budget, new WeakSet());
-    return {
-      equal,
-      addedKeys: [],
-      removedKeys: [],
-      changedKeys: equal ? [] : ["value"],
-      truncated: budget.truncated
-    };
-  }
-  const addedKeys = [];
-  const removedKeys = [];
-  const changedKeys = [];
-  const oldObj = oldValue;
-  const newObj = newValue;
-  for (const k of Object.keys(oldObj)) {
-    if (!Object.prototype.hasOwnProperty.call(newObj, k)) {
-      removedKeys.push(k);
-    } else if (!deepEqual(oldObj[k], newObj[k], maxDepth - 1, budget, new WeakSet())) {
-      changedKeys.push(k);
-    }
-  }
-  for (const k of Object.keys(newObj)) {
-    if (!Object.prototype.hasOwnProperty.call(oldObj, k)) addedKeys.push(k);
-  }
-  return {
-    equal: addedKeys.length === 0 && removedKeys.length === 0 && changedKeys.length === 0,
-    addedKeys,
-    removedKeys,
-    changedKeys,
-    truncated: budget.truncated
-  };
-}
-
-// ============================================================================
-// toDiffable — render normalizer
-// ============================================================================
-
-const TO_DIFFABLE_MAX_DEPTH = 12;
-
-/**
- * Convert a value tree into plain JSON the render-layer diff viewers handle
- * faithfully. Dates → ISO strings, Maps → objects, Sets → arrays,
- * BigInt → "123n", TypedArrays/cycles/depth-overflow → placeholder strings.
- * Functions become "[Function]" (providers have already recorded real ones).
- */
-export function toDiffable(value) {
-  return normalizeForDiff(value, TO_DIFFABLE_MAX_DEPTH, new WeakSet());
-}
-function normalizeForDiff(value, depth, seen) {
-  if (value === null || value === undefined) return value;
-  const t = typeof value;
-  if (t === "string" || t === "boolean") return value;
-  if (t === "number") {
-    return Number.isFinite(value) ? value : String(value);
-  }
-  if (t === "bigint") return `${String(value)}n`;
-  if (t === "function") return "[Function]";
-  if (t === "symbol") return String(value);
-  if (t !== "object") return String(value);
-  if (value instanceof Date) return value.toISOString();
-  if (value instanceof RegExp) return String(value);
-  if (value instanceof Error) return `[${value.name}: ${value.message}]`;
-  if (typeof URL !== "undefined" && value instanceof URL) return value.href;
-  if (isTypedArray(value)) {
-    return `<${value.constructor.name} ${value.byteLength} bytes>`;
-  }
-  if (depth <= 0) return "[Max depth]";
-  if (seen.has(value)) return "[Circular]";
-  seen.add(value);
-  if (value instanceof Map) {
-    const out = {};
-    for (const [k, v] of value.entries()) {
-      const key = typeof k === "string" ? k : JSON.stringify(toDiffable(k));
-      out[key] = normalizeForDiff(v, depth - 1, seen);
-    }
-    return out;
-  }
-  if (value instanceof Set) {
-    return Array.from(value.values()).map(v => normalizeForDiff(v, depth - 1, seen));
-  }
-  if (Array.isArray(value)) {
-    return value.map(v => normalizeForDiff(v, depth - 1, seen));
-  }
-  const out = {};
-  for (const [k, v] of Object.entries(value)) {
-    out[k] = normalizeForDiff(v, depth - 1, seen);
-  }
-  return out;
-}
-
-// ============================================================================
-// Size probe — O(limit) early-bail, cycle-safe
-// ============================================================================
-
-/**
- * True when `value`'s JSON form is likely larger than `limitBytes`. Iterative
- * walk that bails the moment the running estimate crosses the limit, so cost
- * is O(limit) regardless of payload size (the redux store's `jsonLongerThan`
- * lesson: a full stringify per check froze enterprise-scale apps).
- */
-export function jsonLikelyLargerThan(value, limitBytes) {
-  let size = 0;
-  const stack = [value];
-  const seenObjects = new Set();
-  while (stack.length > 0) {
-    const v = stack.pop();
-    if (v === null || v === undefined) {
-      size += 4;
-    } else if (typeof v === "string") {
-      size += v.length + 2;
-    } else if (typeof v === "number" || typeof v === "boolean") {
-      size += 8;
-    } else if (typeof v === "bigint") {
-      size += String(v).length + 1;
-    } else if (typeof v === "object") {
-      if (seenObjects.has(v)) continue;
-      seenObjects.add(v);
-      if (v instanceof Date || v instanceof RegExp) {
-        size += 32;
-      } else if (isTypedArray(v)) {
-        size += v.byteLength;
-      } else if (v instanceof Map) {
-        for (const [k, val] of v.entries()) {
-          stack.push(k, val);
-          size += 4;
-        }
-      } else if (v instanceof Set) {
-        for (const val of v.values()) {
-          stack.push(val);
-          size += 2;
-        }
-      } else if (Array.isArray(v)) {
-        for (const item of v) stack.push(item);
-        size += 2 * v.length + 2;
-      } else {
-        for (const [k, val] of Object.entries(v)) {
-          size += k.length + 4;
-          stack.push(val);
-        }
-      }
-    }
-    if (size > limitBytes) return true;
-  }
-  return false;
-}
+"use strict";function m(e){if(typeof e!=="object"||e===null)return false;const t=Object.getPrototypeOf(e);return t===Object.prototype||t===null}function l(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}export function boundedDeepEqual(e,t,r){const f={nodes:r?.maxNodes??2e3,truncated:false};return y(e,t,r?.maxDepth??8,f,new WeakSet)}function y(e,t,r,f,i){if(f.nodes--<=0){f.truncated=true;return false}if(Object.is(e,t))return true;if(typeof e!==typeof t)return false;if(typeof e!=="object"||e===null||t===null){return typeof e==="function"&&typeof t==="function"}if(e instanceof Date||t instanceof Date){return e instanceof Date&&t instanceof Date&&e.getTime()===t.getTime()}if(e instanceof RegExp||t instanceof RegExp){return e instanceof RegExp&&t instanceof RegExp&&e.source===t.source&&e.flags===t.flags}if(e instanceof Error||t instanceof Error){return e instanceof Error&&t instanceof Error&&e.name===t.name&&e.message===t.message}if(typeof URL!=="undefined"&&(e instanceof URL||t instanceof URL)){return e instanceof URL&&t instanceof URL&&e.href===t.href}if(l(e)||l(t)){if(!l(e)||!l(t))return false;if(e.constructor!==t.constructor||e.byteLength!==t.byteLength){return false}const o=new Uint8Array(e.buffer,e.byteOffset,e.byteLength);const u=new Uint8Array(t.buffer,t.byteOffset,t.byteLength);for(let s=0;s<o.length;s++)if(o[s]!==u[s])return false;return true}if(r<=0){f.truncated=true;return false}if(i.has(e)){f.truncated=true;return false}i.add(e);if(e instanceof Map||t instanceof Map){if(!(e instanceof Map)||!(t instanceof Map)||e.size!==t.size){return false}const o=Array.from(e.entries());const u=Array.from(t.entries());for(let s=0;s<o.length;s++){if(!y(o[s][0],u[s][0],r-1,f,i))return false;if(!y(o[s][1],u[s][1],r-1,f,i))return false}return true}if(e instanceof Set||t instanceof Set){if(!(e instanceof Set)||!(t instanceof Set)||e.size!==t.size){return false}const o=Array.from(e.values());const u=Array.from(t.values());for(let s=0;s<o.length;s++){if(!y(o[s],u[s],r-1,f,i))return false}return true}if(Array.isArray(e)||Array.isArray(t)){if(!Array.isArray(e)||!Array.isArray(t)||e.length!==t.length){return false}for(let o=0;o<e.length;o++){if(!y(e[o],t[o],r-1,f,i))return false}return true}const n=Object.keys(e);const c=Object.keys(t);if(n.length!==c.length)return false;for(const o of n){if(!Object.prototype.hasOwnProperty.call(t,o))return false;if(!y(e[o],t[o],r-1,f,i)){return false}}return true}export function objectDiff(e,t,r){const f=r?.maxDepth??8;const i={nodes:r?.maxNodes??2e3,truncated:false};const n=m(e);const c=m(t);if(!n||!c){const a=y(e,t,f,i,new WeakSet);return{equal:a,addedKeys:[],removedKeys:[],changedKeys:a?[]:["value"],truncated:i.truncated}}const o=[];const u=[];const s=[];const g=e;const h=t;for(const a of Object.keys(g)){if(!Object.prototype.hasOwnProperty.call(h,a)){u.push(a)}else if(!y(g[a],h[a],f-1,i,new WeakSet)){s.push(a)}}for(const a of Object.keys(h)){if(!Object.prototype.hasOwnProperty.call(g,a))o.push(a)}return{equal:o.length===0&&u.length===0&&s.length===0,addedKeys:o,removedKeys:u,changedKeys:s,truncated:i.truncated}}const d=12;export function toDiffable(e){return p(e,d,new WeakSet)}function p(e,t,r){if(e===null||e===void 0)return e;const f=typeof e;if(f==="string"||f==="boolean")return e;if(f==="number"){return Number.isFinite(e)?e:String(e)}if(f==="bigint")return`${String(e)}n`;if(f==="function")return"[Function]";if(f==="symbol")return String(e);if(f!=="object")return String(e);if(e instanceof Date)return e.toISOString();if(e instanceof RegExp)return String(e);if(e instanceof Error)return`[${e.name}: ${e.message}]`;if(typeof URL!=="undefined"&&e instanceof URL)return e.href;if(l(e)){return`<${e.constructor.name} ${e.byteLength} bytes>`}if(t<=0)return"[Max depth]";if(r.has(e))return"[Circular]";r.add(e);if(e instanceof Map){const n={};for(const[c,o]of e.entries()){const u=typeof c==="string"?c:JSON.stringify(toDiffable(c));n[u]=p(o,t-1,r)}return n}if(e instanceof Set){return Array.from(e.values()).map(n=>p(n,t-1,r))}if(Array.isArray(e)){return e.map(n=>p(n,t-1,r))}const i={};for(const[n,c]of Object.entries(e)){i[n]=p(c,t-1,r)}return i}export function jsonLikelyLargerThan(e,t){let r=0;const f=[e];const i=new Set;while(f.length>0){const n=f.pop();if(n===null||n===void 0){r+=4}else if(typeof n==="string"){r+=n.length+2}else if(typeof n==="number"||typeof n==="boolean"){r+=8}else if(typeof n==="bigint"){r+=String(n).length+1}else if(typeof n==="object"){if(i.has(n))continue;i.add(n);if(n instanceof Date||n instanceof RegExp){r+=32}else if(l(n)){r+=n.byteLength}else if(n instanceof Map){for(const[c,o]of n.entries()){f.push(c,o);r+=4}}else if(n instanceof Set){for(const c of n.values()){f.push(c);r+=2}}else if(Array.isArray(n)){for(const c of n)f.push(c);r+=2*n.length+2}else{for(const[c,o]of Object.entries(n)){r+=c.length+4;f.push(o)}}}if(r>t)return true}return false}

package/lib/module/dataViewer/timestampDiff.js

@@ -1,139 +1 @@
-"use strict";
-
-/**
- * Timestamp detection for diff views.
- *
- * `1787085897165 → 1787012175875` is unreadable. It is also the single most
- * common diff in a devtool: `lastSyncTimestamp`, `expiresAt`, `updatedAt`,
- * every cache stamp. This turns that pair into "20h 29m earlier" plus both
- * instants spelled out, WITHOUT hiding the raw values — a devtool that
- * silently reinterprets what is stored is worse than one that says nothing.
- *
- * DETECTION IS DELIBERATELY NARROW, because the failure mode is confidently
- * mislabelling an id or a counter as a date:
- *  - Epoch milliseconds only in [2001-09-09, 2100), i.e. 13 digits.
- *  - Epoch seconds only in the same window, i.e. 10 digits.
- *    The two ranges cannot overlap, so a value is never ambiguous.
- *  - ISO 8601 strings that both match the shape AND parse.
- *  - BOTH sides must be the same kind. An ISO string against an epoch number
- *    is a representation change, not a time delta, and reporting a gap there
- *    would bury the more interesting fact.
- */
-
-/** Units we recognize. A pair must agree on one of them. */
-
-/** 2001-09-09 — below this, a 13-digit-ish number is not a plausible stamp. */
-const MS_MIN = 1_000_000_000_000;
-/** 2100-01-01. */
-const MS_MAX = 4_102_444_800_000;
-const S_MIN = 1_000_000_000;
-const S_MAX = 4_102_444_800;
-
-/** Date, or date-time with optional seconds/fraction/zone. */
-const ISO_RE = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
-function fromNumber(n) {
-  if (!Number.isInteger(n)) return null;
-  if (n >= MS_MIN && n < MS_MAX) return {
-    kind: "epoch-ms",
-    epochMs: n
-  };
-  if (n >= S_MIN && n < S_MAX) return {
-    kind: "epoch-s",
-    epochMs: n * 1000
-  };
-  return null;
-}
-
-/**
- * Read one value as an instant, or null when it isn't confidently a time.
- * Numeric strings count: storage backends hand back everything as strings.
- */
-export function detectTimestamp(value) {
-  if (value instanceof Date) {
-    const ms = value.getTime();
-    return Number.isFinite(ms) ? {
-      kind: "iso",
-      epochMs: ms
-    } : null;
-  }
-  if (typeof value === "number") return fromNumber(value);
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  if (trimmed === "") return null;
-  if (/^\d+$/.test(trimmed)) return fromNumber(Number(trimmed));
-  if (!ISO_RE.test(trimmed)) return null;
-  const parsed = Date.parse(trimmed);
-  return Number.isFinite(parsed) ? {
-    kind: "iso",
-    epochMs: parsed
-  } : null;
-}
-function two(n) {
-  return n < 10 ? `0${n}` : String(n);
-}
-
-/** Local wall-clock, fixed format — a devtool wants it sortable, not chatty. */
-export function formatInstant(epochMs) {
-  const d = new Date(epochMs);
-  return `${d.getFullYear()}-${two(d.getMonth() + 1)}-${two(d.getDate())} ` + `${two(d.getHours())}:${two(d.getMinutes())}:${two(d.getSeconds())}`;
-}
-
-/** Coarsest two units that still carry the magnitude: "3d 4h", "5m 30s". */
-export function formatDuration(ms) {
-  const abs = Math.abs(ms);
-  if (abs < 1000) return `${abs}ms`;
-  const seconds = Math.floor(abs / 1000);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.floor(seconds / 60);
-  const restSeconds = seconds % 60;
-  if (minutes < 60) return restSeconds ? `${minutes}m ${restSeconds}s` : `${minutes}m`;
-  const hours = Math.floor(minutes / 60);
-  const restMinutes = minutes % 60;
-  if (hours < 24) return restMinutes ? `${hours}h ${restMinutes}m` : `${hours}h`;
-  const days = Math.floor(hours / 24);
-  const restHours = hours % 24;
-  return restHours ? `${days}d ${restHours}h` : `${days}d`;
-}
-function pair(oldValue, newValue, path) {
-  const before = detectTimestamp(oldValue);
-  const after = detectTimestamp(newValue);
-  if (!before || !after || before.kind !== after.kind) return null;
-  const deltaMs = after.epochMs - before.epochMs;
-  return {
-    path,
-    kind: before.kind,
-    deltaMs,
-    deltaLabel: deltaMs === 0 ? "same instant" : `${formatDuration(deltaMs)} ${deltaMs < 0 ? "earlier" : "later"}`,
-    fromLabel: formatInstant(before.epochMs),
-    toLabel: formatInstant(after.epochMs)
-  };
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
-}
-
-/** Beyond a handful the bar stops being a summary and becomes the diff. */
-const MAX_DELTAS = 6;
-
-/**
- * Every timestamp pair worth explaining in a diff of these two values.
- *
- * Scalars give at most one entry. Plain objects are inspected ONE level deep
- * — enough for the `{ updatedAt, expiresAt }` shape that dominates, without
- * walking a whole document to hunt for dates.
- */
-export function describeTimestampDeltas(oldValue, newValue) {
-  const scalar = pair(oldValue, newValue);
-  if (scalar) return [scalar];
-  if (!isPlainObject(oldValue) || !isPlainObject(newValue)) return [];
-  const out = [];
-  for (const key of Object.keys(oldValue)) {
-    if (out.length >= MAX_DELTAS) break;
-    if (!(key in newValue)) continue;
-    // Unchanged stamps are noise: the point is explaining what MOVED.
-    if (Object.is(oldValue[key], newValue[key])) continue;
-    const entry = pair(oldValue[key], newValue[key], key);
-    if (entry) out.push(entry);
-  }
-  return out;
-}
+"use strict";const M=1e12;const p=41024448e5;const h=1e9;const $=4102444800;const _=/^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;function d(t){if(!Number.isInteger(t))return null;if(t>=M&&t<p)return{kind:"epoch-ms",epochMs:t};if(t>=h&&t<$)return{kind:"epoch-s",epochMs:t*1e3};return null}export function detectTimestamp(t){if(t instanceof Date){const r=t.getTime();return Number.isFinite(r)?{kind:"iso",epochMs:r}:null}if(typeof t==="number")return d(t);if(typeof t!=="string")return null;const n=t.trim();if(n==="")return null;if(/^\d+$/.test(n))return d(Number(n));if(!_.test(n))return null;const o=Date.parse(n);return Number.isFinite(o)?{kind:"iso",epochMs:o}:null}function i(t){return t<10?`0${t}`:String(t)}export function formatInstant(t){const n=new Date(t);return`${n.getFullYear()}-${i(n.getMonth()+1)}-${i(n.getDate())} ${i(n.getHours())}:${i(n.getMinutes())}:${i(n.getSeconds())}`}export function formatDuration(t){const n=Math.abs(t);if(n<1e3)return`${n}ms`;const o=Math.floor(n/1e3);if(o<60)return`${o}s`;const r=Math.floor(o/60);const e=o%60;if(r<60)return e?`${r}m ${e}s`:`${r}m`;const s=Math.floor(r/60);const c=r%60;if(s<24)return c?`${s}h ${c}m`:`${s}h`;const f=Math.floor(s/24);const u=s%24;return u?`${f}d ${u}h`:`${f}d`}function a(t,n,o){const r=detectTimestamp(t);const e=detectTimestamp(n);if(!r||!e||r.kind!==e.kind)return null;const s=e.epochMs-r.epochMs;return{path:o,kind:r.kind,deltaMs:s,deltaLabel:s===0?"same instant":`${formatDuration(s)} ${s<0?"earlier":"later"}`,fromLabel:formatInstant(r.epochMs),toLabel:formatInstant(e.epochMs)}}function m(t){return typeof t==="object"&&t!==null&&!Array.isArray(t)&&!(t instanceof Date)}const b=6;export function describeTimestampDeltas(t,n){const o=a(t,n);if(o)return[o];if(!m(t)||!m(n))return[];const r=[];for(const e of Object.keys(t)){if(r.length>=b)break;if(!(e in n))continue;if(Object.is(t[e],n[e]))continue;const s=a(t[e],n[e],e);if(s)r.push(s)}return r}