strict-diff 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,98 @@
+import { BuiltinType } from "builtin-type";
+
+//#region src/index.d.ts
+/**
+ * A path segment representing an object's own property.
+ *
+ * The path segment points to the property's {@link PropertyDescriptor}. Another
+ * path segment must be used to target the descriptor's `[[Value]]` slot.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Enumerability_and_ownership_of_properties
+ */
+type PropertyPathSegment = {
+  kind: `property`; /** The property's index in the array returned by {@link Reflect.ownKeys}. */
+  index: number;
+  /**
+   * The property's key.
+   *
+   * Valid numeric indices are provided as numbers.
+   */
+  key: number | string | symbol;
+};
+/**
+ * A path segment representing an object's internal slot.
+ *
+ * @see https://tc39.es/ecma262/multipage/ecmascript-data-types-and-values.html#sec-object-internal-methods-and-internal-slots
+ */
+type InternalSlotPathSegment = {
+  kind: `internal-slot`;
+  /**
+   * The name of the slot.
+   *
+   * For ECMAScript defined types, this will be the name of the internal slot
+   * excluding the `[[...]]` delimiters.
+   *
+   * For WHATWG defined types, this will be the name of the IDL attribute.
+   *
+   * @see https://tc39.es/ecma262/multipage/ecmascript-data-types-and-values.html#sec-object-internal-methods-and-internal-slots
+   * @see https://webidl.spec.whatwg.org/#idl-attributes
+   */
+  slot: string;
+};
+type PathSegment = PropertyPathSegment | InternalSlotPathSegment;
+/**
+ * The path from a root value to some subvalue within it.
+ *
+ * An empty path points to the root value.
+ */
+type Path = PathSegment[];
+/** A diff between the builtin types of left and right values. */
+type TypeDiff = {
+  kind: `type`;
+  /**
+   * The path from the left and right root values to where they have a type
+   * diff.
+   */
+  path: Path; /** The left value's type at {@link TypeDiff.path}. */
+  left: BuiltinType; /** The left value's type at {@link TypeDiff.path}. */
+  right: BuiltinType;
+};
+/** A diff between the keys of left and right objects. */
+type KeyDiff = {
+  kind: `key`;
+  /**
+   * The path from the left and right root values to the left and right
+   * subobjects where they have a key diff at {@link KeyDiff.index}.
+   */
+  path: Path;
+  /**
+   * The index in the array returned by {@link Reflect.ownKeys} where the diff
+   * is.
+   */
+  index: number; /** The left key at {@link KeyDiff.path}. */
+  left: PropertyKey | undefined; /** The right key at {@link KeyDiff.path}. */
+  right: PropertyKey | undefined;
+};
+/** A diff between left and right values of the same type. */
+type ValueDiff = {
+  kind: `value`; /** The path from the two root values to where they have a value diff. */
+  path: Path; /** The left value at {@link ValueDiff.path}. */
+  left: unknown; /** The right value at {@link ValueDiff.path}. */
+  right: unknown;
+};
+type ReferenceDiff = {
+  kind: `reference`; /** The path from the two root values to where they have a reference diff. */
+  path: Path;
+  /**
+   * The path from the left root value to where the left value was first seen.
+   */
+  leftFirstSeenPath: Path | undefined;
+  /**
+   * The path from the right root value to where the right value was first seen.
+   */
+  rightFirstSeenPath: Path | undefined;
+};
+type Diff = TypeDiff | KeyDiff | ValueDiff | ReferenceDiff;
+declare const strictDiff: (value1: unknown, value2: unknown) => Iterable<Diff>;
+//#endregion
+export { Diff, InternalSlotPathSegment, KeyDiff, Path, PathSegment, PropertyPathSegment, ReferenceDiff, TypeDiff, ValueDiff, strictDiff as default };

package/dist/index.js

@@ -0,0 +1,2 @@
+import e from"builtin-type";const a=(e,a)=>({[Symbol.iterator]:()=>t(e,a,[],r())}),r=()=>({t:new Map,o:new Map});function*t(a,r,c,l){if(Object.is(a,r))return;const p=e(a),d=e(r);if(p!==d)return void(yield{kind:"type",path:[...c],left:p,right:d});if(!o(a)||!o(r))return void(yield{kind:"value",path:[...c],left:a,right:r});const T=l.t.get(a),y=l.o.get(r);T||y?n(T,y)||(yield{kind:"reference",path:[...c],leftFirstSeenPath:T,rightFirstSeenPath:y}):(l.t.set(a,c),l.o.set(r,c),yield*function*(e,a,r,o,n){const c=s(e,a),l=s(e,r),i=new Set([...Object.keys(c),...Object.keys(l)]);for(const e of i)yield*t(c[e],l[e],[...o,{kind:"internal-slot",slot:e}],n)}(p,a,r,c,l),yield*function*(e,a,r,o){const n=Reflect.ownKeys(e),c=Reflect.ownKeys(a),s=Math.max(n.length,c.length);for(let l=0;l<s;l++){const s=i(n[l]),p=i(c[l]);if(s!==p){yield{kind:"key",path:[...r],index:l,left:s,right:p};continue}const d=s,T=Object.getOwnPropertyDescriptor(e,d),y=Object.getOwnPropertyDescriptor(a,d);for(const e of m)yield*t(T[e],y[e],[...r,{kind:"property",index:l,key:d},{kind:"internal-slot",slot:e[0].toUpperCase()+e.slice(1)}],o)}}(a,r,c,l))}const o=e=>{const a=typeof e;return"object"===a&&!!e||"function"===a},n=(e,a)=>e===a||!(!e||!a)&&(e.length===a.length&&e.every((e,r)=>c(e,a[r]))),c=(e,a)=>{if(e.kind!==a.kind)return!1;switch(e.kind){case"property":{const r=a;return e.index===r.index&&e.key===r.key}case"internal-slot":return e.slot===a.slot}};const s=(e,a)=>{const r={Prototype:Object.getPrototypeOf(a),Extensible:Object.isExtensible(a)};switch(e){case"Boolean":case"Number":case"BigInt":case"String":case"Symbol":{const t=globalThis[e].prototype.valueOf;r[`${e}Data`]=t.call(a);break}case"Map":r.MapData=[...Map.prototype.entries.call(a)];break;case"Set":r.SetData=[...Set.prototype.values.call(a)];break;case"Function":case"GeneratorFunction":case"AsyncFunction":case"AsyncGeneratorFunction":r.SourceText=Function.prototype.toString.call(a);break;case"Date":r.DateValue=Date.prototype.getTime.call(a);break;case"RegExp":r.OriginalSource=l(RegExp,"source",a),r.OriginalFlags=l(RegExp,"flags",a);break;case"URL":r.href=l(URL,"href",a);break;case"URLSearchParams":r.list=URLSearchParams.prototype.toString.call(a);break;case"WeakRef":r.WeakRefTarget=WeakRef.prototype.deref.call(a);break;case"ArrayBuffer":if(l(ArrayBuffer,"detached",a)){r.ArrayBufferData=null;break}case"SharedArrayBuffer":{const t=globalThis[e];r.ArrayBufferByteLength=l(t,"byteLength",a),r.ArrayBufferMaxByteLength=l(t,"maxByteLength",a),r.ArrayBufferData=[...new Uint8Array(a)];break}case"Buffer":case"Int8Array":case"Uint8Array":case"Uint8ClampedArray":case"Int16Array":case"Uint16Array":case"Int32Array":case"Uint32Array":case"BigInt64Array":case"BigUint64Array":case"Float16Array":case"Float32Array":case"Float64Array":case"DataView":{const t=globalThis[e];r.ByteOffset=l(t,"byteOffset",a),r.ByteLength=l(t,"byteLength",a),r.ViewedArrayBuffer=l(t,"buffer",a);break}case"Temporal.Duration":r.Years=l(Temporal.Duration,"years",a),r.Months=l(Temporal.Duration,"months",a),r.Weeks=l(Temporal.Duration,"weeks",a),r.Days=l(Temporal.Duration,"days",a),r.Hours=l(Temporal.Duration,"hours",a),r.Minutes=l(Temporal.Duration,"minutes",a),r.Seconds=l(Temporal.Duration,"seconds",a),r.Milliseconds=l(Temporal.Duration,"milliseconds",a),r.Microseconds=l(Temporal.Duration,"microseconds",a),r.Nanoseconds=l(Temporal.Duration,"nanoseconds",a);break;case"Temporal.Instant":r.EpochNanoseconds=l(Temporal.Instant,"epochNanoseconds",a);break;case"Temporal.PlainDate":r.Calendar=l(Temporal.PlainDate,"calendarId",a),r.Year=l(Temporal.PlainDate,"year",a),r.Month=l(Temporal.PlainDate,"month",a),r.Day=l(Temporal.PlainDate,"day",a);break;case"Temporal.PlainDateTime":r.Calendar=l(Temporal.PlainDateTime,"calendarId",a),r.Year=l(Temporal.PlainDateTime,"year",a),r.Month=l(Temporal.PlainDateTime,"month",a),r.Day=l(Temporal.PlainDateTime,"day",a),r.Hour=l(Temporal.PlainDateTime,"hour",a),r.Minute=l(Temporal.PlainDateTime,"minute",a),r.Second=l(Temporal.PlainDateTime,"second",a),r.Millisecond=l(Temporal.PlainDateTime,"millisecond",a),r.Microsecond=l(Temporal.PlainDateTime,"microsecond",a),r.Nanosecond=l(Temporal.PlainDateTime,"nanosecond",a);break;case"Temporal.PlainMonthDay":r.Calendar=l(Temporal.PlainMonthDay,"calendarId",a),r.MonthCode=l(Temporal.PlainMonthDay,"monthCode",a),r.Day=l(Temporal.PlainMonthDay,"day",a);break;case"Temporal.PlainTime":r.Hour=l(Temporal.PlainTime,"hour",a),r.Minute=l(Temporal.PlainTime,"minute",a),r.Second=l(Temporal.PlainTime,"second",a),r.Millisecond=l(Temporal.PlainTime,"millisecond",a),r.Microsecond=l(Temporal.PlainTime,"microsecond",a),r.Nanosecond=l(Temporal.PlainTime,"nanosecond",a);break;case"Temporal.PlainYearMonth":r.Calendar=l(Temporal.PlainYearMonth,"calendarId",a),r.Year=l(Temporal.PlainYearMonth,"year",a),r.Month=l(Temporal.PlainYearMonth,"month",a);break;case"Temporal.ZonedDateTime":r.Calendar=l(Temporal.ZonedDateTime,"calendarId",a),r.TimeZone=l(Temporal.ZonedDateTime,"timeZoneId",a),r.EpochNanoseconds=l(Temporal.ZonedDateTime,"epochNanoseconds",a)}return r},l=(e,a,r)=>{for(let t=e.prototype;t;t=Object.getPrototypeOf(t)){const e=Object.getOwnPropertyDescriptor(t,a);if(e)return e.get.call(r)}};const i=e=>{if(void 0===e)return;if("string"!=typeof e)return e;const a=Number(e);return Number.isInteger(a)&&a>=0&&a<=2**32-2&&String(a)===e?a:e},m=["configurable","enumerable","writable","value","get","set"];export{a as default};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import builtinType from 'builtin-type'\nimport type { BuiltinType } from 'builtin-type'\n\n/**\n * A path segment representing an object's own property.\n *\n * The path segment points to the property's {@link PropertyDescriptor}. Another\n * path segment must be used to target the descriptor's `[[Value]]` slot.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Enumerability_and_ownership_of_properties\n */\nexport type PropertyPathSegment = {\n  kind: `property`\n\n  /** The property's index in the array returned by {@link Reflect.ownKeys}. */\n  index: number\n\n  /**\n   * The property's key.\n   *\n   * Valid numeric indices are provided as numbers.\n   */\n  key: number | string | symbol\n}\n\n/**\n * A path segment representing an object's internal slot.\n *\n * @see https://tc39.es/ecma262/multipage/ecmascript-data-types-and-values.html#sec-object-internal-methods-and-internal-slots\n */\nexport type InternalSlotPathSegment = {\n  kind: `internal-slot`\n\n  /**\n   * The name of the slot.\n   *\n   * For ECMAScript defined types, this will be the name of the internal slot\n   * excluding the `[[...]]` delimiters.\n   *\n   * For WHATWG defined types, this will be the name of the IDL attribute.\n   *\n   * @see https://tc39.es/ecma262/multipage/ecmascript-data-types-and-values.html#sec-object-internal-methods-and-internal-slots\n   * @see https://webidl.spec.whatwg.org/#idl-attributes\n   */\n  slot: string\n}\n\nexport type PathSegment = PropertyPathSegment | InternalSlotPathSegment\n\n/**\n * The path from a root value to some subvalue within it.\n *\n * An empty path points to the root value.\n */\nexport type Path = PathSegment[]\n\n/** A diff between the builtin types of left and right values. */\nexport type TypeDiff = {\n  kind: `type`\n\n  /**\n   * The path from the left and right root values to where they have a type\n   * diff.\n   */\n  path: Path\n\n  /** The left value's type at {@link TypeDiff.path}. */\n  left: BuiltinType\n\n  /** The left value's type at {@link TypeDiff.path}. */\n  right: BuiltinType\n}\n\n/** A diff between the keys of left and right objects. */\nexport type KeyDiff = {\n  kind: `key`\n\n  /**\n   * The path from the left and right root values to the left and right\n   * subobjects where they have a key diff at {@link KeyDiff.index}.\n   */\n  path: Path\n\n  /**\n   * The index in the array returned by {@link Reflect.ownKeys} where the diff\n   * is.\n   */\n  index: number\n\n  /** The left key at {@link KeyDiff.path}. */\n  left: PropertyKey | undefined\n\n  /** The right key at {@link KeyDiff.path}. */\n  right: PropertyKey | undefined\n}\n\n/** A diff between left and right values of the same type. */\nexport type ValueDiff = {\n  kind: `value`\n\n  /** The path from the two root values to where they have a value diff. */\n  path: Path\n\n  /** The left value at {@link ValueDiff.path}. */\n  left: unknown\n\n  /** The right value at {@link ValueDiff.path}. */\n  right: unknown\n}\n\nexport type ReferenceDiff = {\n  kind: `reference`\n\n  /** The path from the two root values to where they have a reference diff. */\n  path: Path\n\n  /**\n   * The path from the left root value to where the left value was first seen.\n   */\n  leftFirstSeenPath: Path | undefined\n\n  /**\n   * The path from the right root value to where the right value was first seen.\n   */\n  rightFirstSeenPath: Path | undefined\n}\n\nexport type Diff = TypeDiff | KeyDiff | ValueDiff | ReferenceDiff\n\nconst strictDiff = (value1: unknown, value2: unknown): Iterable<Diff> => ({\n  [Symbol.iterator]: () => enumerateDiffs(value1, value2, [], makeState()),\n})\n\ntype State = {\n  _leftFirstSeenPaths: Map<object, Path>\n  _rightFirstSeenPaths: Map<object, Path>\n}\n\nconst makeState = (): State => ({\n  _leftFirstSeenPaths: new Map(),\n  _rightFirstSeenPaths: new Map(),\n})\n\nfunction* enumerateDiffs(\n  left: unknown,\n  right: unknown,\n  path: Path,\n  state: State,\n): IterableIterator<Diff> {\n  if (Object.is(left, right)) {\n    return\n  }\n\n  const leftType = builtinType(left)\n  const rightType = builtinType(right)\n  if (leftType !== rightType) {\n    yield { kind: `type`, path: [...path], left: leftType, right: rightType }\n    return\n  }\n\n  if (!isObject(left) || !isObject(right)) {\n    yield { kind: `value`, path: [...path], left, right }\n    return\n  }\n\n  const leftFirstSeenPath = state._leftFirstSeenPaths.get(left)\n  const rightFirstSeenPath = state._rightFirstSeenPaths.get(right)\n  if (leftFirstSeenPath || rightFirstSeenPath) {\n    if (!pathsEqual(leftFirstSeenPath, rightFirstSeenPath)) {\n      yield {\n        kind: `reference`,\n        path: [...path],\n        leftFirstSeenPath,\n        rightFirstSeenPath,\n      }\n    }\n    return\n  }\n  state._leftFirstSeenPaths.set(left, path)\n  state._rightFirstSeenPaths.set(right, path)\n\n  yield* enumerateInternalSlotDiffs(leftType, left, right, path, state)\n  yield* enumerateOwnPropertyDiffs(left, right, path, state)\n}\n\nconst isObject = (value: unknown): value is object => {\n  const type = typeof value\n  return (type === `object` && !!value) || type === `function`\n}\n\nconst pathsEqual = (\n  path1: Path | undefined,\n  path2: Path | undefined,\n): boolean => {\n  if (path1 === path2) {\n    return true\n  }\n  if (!path1 || !path2) {\n    return false\n  }\n  if (path1.length !== path2.length) {\n    return false\n  }\n  return path1.every((segment, index) =>\n    pathSegmentsEqual(segment, path2[index]!),\n  )\n}\n\nconst pathSegmentsEqual = (\n  segment1: PathSegment,\n  segment2: PathSegment,\n): boolean => {\n  if (segment1.kind !== segment2.kind) {\n    return false\n  }\n\n  switch (segment1.kind) {\n    case `property`: {\n      const propertySegment2 = segment2 as PropertyPathSegment\n      return (\n        segment1.index === propertySegment2.index &&\n        segment1.key === propertySegment2.key\n      )\n    }\n    case `internal-slot`:\n      return segment1.slot === (segment2 as InternalSlotPathSegment).slot\n  }\n}\n\nfunction* enumerateInternalSlotDiffs(\n  type: BuiltinType,\n  left: object,\n  right: object,\n  path: Path,\n  state: State,\n): Generator<Diff> {\n  const leftSlots = getInternalSlots(type, left)\n  const rightSlots = getInternalSlots(type, right)\n\n  const slots = new Set([...Object.keys(leftSlots), ...Object.keys(rightSlots)])\n  for (const slot of slots) {\n    yield* enumerateDiffs(\n      leftSlots[slot],\n      rightSlots[slot],\n      [...path, { kind: `internal-slot`, slot }],\n      state,\n    )\n  }\n}\n\nconst getInternalSlots = (\n  type: BuiltinType,\n  value: object,\n): Record<string, unknown> => {\n  const slots: Record<string, unknown> = {\n    Prototype: Object.getPrototypeOf(value),\n    Extensible: Object.isExtensible(value),\n  }\n\n  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check\n  switch (type) {\n    case `Boolean`:\n    case `Number`:\n    case `BigInt`:\n    case `String`:\n    case `Symbol`: {\n      // https://tc39.es/ecma262/#sec-thisbooleanvalue\n      // https://tc39.es/ecma262/#sec-thisnumbervalue\n      // https://tc39.es/ecma262/#sec-thisbigintvalue\n      // https://tc39.es/ecma262/#sec-thisstringvalue\n      // https://tc39.es/ecma262/#sec-thissymbolvalue\n      const valueOf: (this: object) => unknown =\n        globalThis[type].prototype.valueOf\n      slots[`${type}Data`] = valueOf.call(value)\n      break\n    }\n    case `Map`:\n      // https://tc39.es/ecma262/#sec-createmapiterator\n      slots.MapData = [...Map.prototype.entries.call(value)]\n      break\n    case `Set`:\n      // https://tc39.es/ecma262/#sec-createsetiterator\n      slots.SetData = [...Set.prototype.values.call(value)]\n      break\n    case `Function`:\n    case `GeneratorFunction`:\n    case `AsyncFunction`:\n    case `AsyncGeneratorFunction`:\n      // https://tc39.es/ecma262/#sec-function.prototype.tostring\n      slots.SourceText = Function.prototype.toString.call(value)\n      break\n    case `Date`:\n      // https://tc39.es/ecma262/#sec-date.prototype.gettime\n      slots.DateValue = Date.prototype.getTime.call(value as Date)\n      break\n    case `RegExp`:\n      // https://tc39.es/ecma262/#sec-get-regexp.prototype.source\n      slots.OriginalSource = accessGetter(RegExp, `source`, value)\n      // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags\n      slots.OriginalFlags = accessGetter(RegExp, `flags`, value)\n      break\n    case `URL`:\n      // https://url.spec.whatwg.org/#url-class\n      slots.href = accessGetter(URL, `href`, value)\n      break\n    case `URLSearchParams`:\n      // https://url.spec.whatwg.org/#urlsearchparams\n      slots.list = URLSearchParams.prototype.toString.call(value)\n      break\n    case `WeakRef`:\n      // https://tc39.es/ecma262/#sec-weak-ref.prototype.deref\n      slots.WeakRefTarget = WeakRef.prototype.deref.call(value)\n      break\n    case `ArrayBuffer`:\n      if (accessGetter(ArrayBuffer, `detached`, value)) {\n        slots.ArrayBufferData = null\n        break\n      }\n    // Falls through on purpose.\n    // eslint-disable-next-line no-fallthrough\n    case `SharedArrayBuffer`: {\n      const Class = globalThis[type]\n      slots.ArrayBufferByteLength = accessGetter(Class, `byteLength`, value)\n      slots.ArrayBufferMaxByteLength = accessGetter(\n        Class,\n        `maxByteLength`,\n        value,\n      )\n      slots.ArrayBufferData = [\n        ...new Uint8Array(value as ArrayBuffer | SharedArrayBuffer),\n      ]\n      break\n    }\n    case `Buffer`:\n    case `Int8Array`:\n    case `Uint8Array`:\n    case `Uint8ClampedArray`:\n    case `Int16Array`:\n    case `Uint16Array`:\n    case `Int32Array`:\n    case `Uint32Array`:\n    case `BigInt64Array`:\n    case `BigUint64Array`:\n    case `Float16Array`:\n    case `Float32Array`:\n    case `Float64Array`:\n    case `DataView`: {\n      const Class = globalThis[type]\n      slots.ByteOffset = accessGetter(Class, `byteOffset`, value)\n      slots.ByteLength = accessGetter(Class, `byteLength`, value)\n      slots.ViewedArrayBuffer = accessGetter(Class, `buffer`, value)\n      break\n    }\n    case `Temporal.Duration`:\n      slots.Years = accessGetter(Temporal.Duration, `years`, value)\n      slots.Months = accessGetter(Temporal.Duration, `months`, value)\n      slots.Weeks = accessGetter(Temporal.Duration, `weeks`, value)\n      slots.Days = accessGetter(Temporal.Duration, `days`, value)\n      slots.Hours = accessGetter(Temporal.Duration, `hours`, value)\n      slots.Minutes = accessGetter(Temporal.Duration, `minutes`, value)\n      slots.Seconds = accessGetter(Temporal.Duration, `seconds`, value)\n      slots.Milliseconds = accessGetter(\n        Temporal.Duration,\n        `milliseconds`,\n        value,\n      )\n      slots.Microseconds = accessGetter(\n        Temporal.Duration,\n        `microseconds`,\n        value,\n      )\n      slots.Nanoseconds = accessGetter(Temporal.Duration, `nanoseconds`, value)\n      break\n    case `Temporal.Instant`:\n      slots.EpochNanoseconds = accessGetter(\n        Temporal.Instant,\n        `epochNanoseconds`,\n        value,\n      )\n      break\n    case `Temporal.PlainDate`:\n      slots.Calendar = accessGetter(Temporal.PlainDate, `calendarId`, value)\n      slots.Year = accessGetter(Temporal.PlainDate, `year`, value)\n      slots.Month = accessGetter(Temporal.PlainDate, `month`, value)\n      slots.Day = accessGetter(Temporal.PlainDate, `day`, value)\n      break\n    case `Temporal.PlainDateTime`:\n      slots.Calendar = accessGetter(Temporal.PlainDateTime, `calendarId`, value)\n      slots.Year = accessGetter(Temporal.PlainDateTime, `year`, value)\n      slots.Month = accessGetter(Temporal.PlainDateTime, `month`, value)\n      slots.Day = accessGetter(Temporal.PlainDateTime, `day`, value)\n      slots.Hour = accessGetter(Temporal.PlainDateTime, `hour`, value)\n      slots.Minute = accessGetter(Temporal.PlainDateTime, `minute`, value)\n      slots.Second = accessGetter(Temporal.PlainDateTime, `second`, value)\n      slots.Millisecond = accessGetter(\n        Temporal.PlainDateTime,\n        `millisecond`,\n        value,\n      )\n      slots.Microsecond = accessGetter(\n        Temporal.PlainDateTime,\n        `microsecond`,\n        value,\n      )\n      slots.Nanosecond = accessGetter(\n        Temporal.PlainDateTime,\n        `nanosecond`,\n        value,\n      )\n      break\n    case `Temporal.PlainMonthDay`:\n      slots.Calendar = accessGetter(Temporal.PlainMonthDay, `calendarId`, value)\n      slots.MonthCode = accessGetter(Temporal.PlainMonthDay, `monthCode`, value)\n      slots.Day = accessGetter(Temporal.PlainMonthDay, `day`, value)\n      break\n    case `Temporal.PlainTime`:\n      slots.Hour = accessGetter(Temporal.PlainTime, `hour`, value)\n      slots.Minute = accessGetter(Temporal.PlainTime, `minute`, value)\n      slots.Second = accessGetter(Temporal.PlainTime, `second`, value)\n      slots.Millisecond = accessGetter(Temporal.PlainTime, `millisecond`, value)\n      slots.Microsecond = accessGetter(Temporal.PlainTime, `microsecond`, value)\n      slots.Nanosecond = accessGetter(Temporal.PlainTime, `nanosecond`, value)\n      break\n    case `Temporal.PlainYearMonth`:\n      slots.Calendar = accessGetter(\n        Temporal.PlainYearMonth,\n        `calendarId`,\n        value,\n      )\n      slots.Year = accessGetter(Temporal.PlainYearMonth, `year`, value)\n      slots.Month = accessGetter(Temporal.PlainYearMonth, `month`, value)\n      break\n    case `Temporal.ZonedDateTime`:\n      slots.Calendar = accessGetter(Temporal.ZonedDateTime, `calendarId`, value)\n      slots.TimeZone = accessGetter(Temporal.ZonedDateTime, `timeZoneId`, value)\n      slots.EpochNanoseconds = accessGetter(\n        Temporal.ZonedDateTime,\n        `epochNanoseconds`,\n        value,\n      )\n      break\n  }\n\n  return slots\n}\n\nconst accessGetter = (\n  cls: { prototype: unknown },\n  key: string,\n  value: object,\n): unknown => {\n  for (\n    let prototype: unknown = cls.prototype;\n    prototype;\n    prototype = Object.getPrototypeOf(prototype)\n  ) {\n    const descriptor = Object.getOwnPropertyDescriptor(prototype, key)\n    if (descriptor) {\n      return descriptor.get!.call(value)\n    }\n  }\n  return undefined\n}\n\nfunction* enumerateOwnPropertyDiffs(\n  left: object,\n  right: object,\n  path: Path,\n  state: State,\n): Generator<Diff> {\n  const leftKeys = Reflect.ownKeys(left)\n  const rightKeys = Reflect.ownKeys(right)\n\n  const keyCount = Math.max(leftKeys.length, rightKeys.length)\n  for (let index = 0; index < keyCount; index++) {\n    const leftKey = maybeConvertToIndex(leftKeys[index])\n    const rightKey = maybeConvertToIndex(rightKeys[index])\n\n    if (leftKey !== rightKey) {\n      yield {\n        kind: `key`,\n        path: [...path],\n        index,\n        left: leftKey,\n        right: rightKey,\n      }\n      continue\n    }\n\n    const key = leftKey!\n    const leftDescriptor = Object.getOwnPropertyDescriptor(left, key)!\n    const rightDescriptor = Object.getOwnPropertyDescriptor(right, key)!\n    for (const descriptorKey of PROPERTY_DESCRIPTOR_KEYS) {\n      yield* enumerateDiffs(\n        leftDescriptor[descriptorKey],\n        rightDescriptor[descriptorKey],\n        [\n          ...path,\n          { kind: `property`, index, key },\n          {\n            kind: `internal-slot` as const,\n            slot: descriptorKey[0]!.toUpperCase() + descriptorKey.slice(1),\n          },\n        ],\n        state,\n      )\n    }\n  }\n}\n\nconst maybeConvertToIndex = (\n  key: PropertyKey | undefined,\n): PropertyKey | undefined => {\n  if (key === undefined) {\n    return undefined\n  }\n\n  if (typeof key !== `string`) {\n    return key\n  }\n\n  const index = Number(key)\n  if (\n    Number.isInteger(index) &&\n    index >= 0 &&\n    index <= 2 ** 32 - 2 &&\n    String(index) === key\n  ) {\n    return index\n  }\n\n  return key\n}\n\nconst PROPERTY_DESCRIPTOR_KEYS = [\n  `configurable`,\n  `enumerable`,\n  `writable`,\n  `value`,\n  `get`,\n  `set`,\n] as const\n\nexport default strictDiff\n"],"mappings":"4BAiIA,MAAM,EAAA,CAAc,EAAiB,KAAA,CAAqC,CACvE,OAAO,UAAA,IAAiB,EAAe,EAAQ,EAAQ,GAAI,OAQxD,EAAA,KAAA,CACJ,EAAqB,IAAI,IACzB,EAAsB,IAAI,MAG5B,SAAU,EACR,EACA,EACA,EACA,GAEA,GAAI,OAAO,GAAG,EAAM,GAClB,OAGF,MAAM,EAAW,EAAY,GACvB,EAAY,EAAY,GAC9B,GAAI,IAAa,EAEf,iBADM,CAAE,KAAM,OAAQ,KAAM,IAAI,GAAO,KAAM,EAAU,MAAO,IAIhE,IAAK,EAAS,KAAU,EAAS,GAE/B,iBADM,CAAE,KAAM,QAAS,KAAM,IAAI,GAAO,OAAM,UAIhD,MAAM,EAAoB,EAAM,EAAoB,IAAI,GAClD,EAAqB,EAAM,EAAqB,IAAI,GACtD,GAAqB,EAClB,EAAW,EAAmB,UAC3B,CACJ,KAAM,YACN,KAAM,IAAI,GACV,oBACA,wBAKN,EAAM,EAAoB,IAAI,EAAM,GACpC,EAAM,EAAqB,IAAI,EAAO,SAkDxC,UACE,EACA,EACA,EACA,EACA,GAEA,MAAM,EAAY,EAAiB,EAAM,GACnC,EAAa,EAAiB,EAAM,GAEpC,EAAQ,IAAI,IAAI,IAAI,OAAO,KAAK,MAAe,OAAO,KAAK,KACjE,IAAK,MAAM,KAAQ,QACV,EACL,EAAU,GACV,EAAW,GACX,IAAI,EAAM,CAAE,KAAM,gBAAiB,SACnC,GAhEG,CAA2B,EAAU,EAAM,EAAO,EAAM,SA2RjE,UACE,EACA,EACA,EACA,GAEA,MAAM,EAAW,QAAQ,QAAQ,GAC3B,EAAY,QAAQ,QAAQ,GAE5B,EAAW,KAAK,IAAI,EAAS,OAAQ,EAAU,QACrD,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAU,IAAS,CAC7C,MAAM,EAAU,EAAoB,EAAS,IACvC,EAAW,EAAoB,EAAU,IAE/C,GAAI,IAAY,EAAU,MAClB,CACJ,KAAM,MACN,KAAM,IAAI,GACV,QACA,KAAM,EACN,MAAO,GAET,SAGF,MAAM,EAAM,EACN,EAAiB,OAAO,yBAAyB,EAAM,GACvD,EAAkB,OAAO,yBAAyB,EAAO,GAC/D,IAAK,MAAM,KAAiB,QACnB,EACL,EAAe,GACf,EAAgB,GAChB,IACK,EACH,CAAE,KAAM,WAAY,QAAO,OAC3B,CACE,KAAM,gBACN,KAAM,EAAc,GAAI,cAAgB,EAAc,MAAM,KAGhE,IAlUC,CAA0B,EAAM,EAAO,EAAM,IAGtD,MAAM,EAAY,IAChB,MAAM,SAAc,EACpB,MAAiB,WAAT,KAAuB,GAAmB,aAAT,GAGrC,EAAA,CACJ,EACA,IAEI,IAAU,MAGT,IAAU,KAGX,EAAM,SAAW,EAAM,QAGpB,EAAM,MAAA,CAAO,EAAS,IAC3B,EAAkB,EAAS,EAAM,MAI/B,EAAA,CACJ,EACA,KAEA,GAAI,EAAS,OAAS,EAAS,KAC7B,OAAO,EAGT,OAAQ,EAAS,MACf,IAAK,WAAY,CACf,MAAM,EAAmB,EACzB,OACE,EAAS,QAAU,EAAiB,OACpC,EAAS,MAAQ,EAAiB,IAGtC,IAAK,gBACH,OAAO,EAAS,OAAU,EAAqC,OAyBrE,MAAM,EAAA,CACJ,EACA,KAEA,MAAM,EAAiC,CACrC,UAAW,OAAO,eAAe,GACjC,WAAY,OAAO,aAAa,IAIlC,OAAQ,GACN,IAAK,UACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SAAU,CAMb,MAAM,EACJ,WAAW,GAAM,UAAU,QAC7B,EAAM,GAAG,SAAc,EAAQ,KAAK,GACpC,MAEF,IAAK,MAEH,EAAM,QAAU,IAAI,IAAI,UAAU,QAAQ,KAAK,IAC/C,MACF,IAAK,MAEH,EAAM,QAAU,IAAI,IAAI,UAAU,OAAO,KAAK,IAC9C,MACF,IAAK,WACL,IAAK,oBACL,IAAK,gBACL,IAAK,yBAEH,EAAM,WAAa,SAAS,UAAU,SAAS,KAAK,GACpD,MACF,IAAK,OAEH,EAAM,UAAY,KAAK,UAAU,QAAQ,KAAK,GAC9C,MACF,IAAK,SAEH,EAAM,eAAiB,EAAa,OAAQ,SAAU,GAEtD,EAAM,cAAgB,EAAa,OAAQ,QAAS,GACpD,MACF,IAAK,MAEH,EAAM,KAAO,EAAa,IAAK,OAAQ,GACvC,MACF,IAAK,kBAEH,EAAM,KAAO,gBAAgB,UAAU,SAAS,KAAK,GACrD,MACF,IAAK,UAEH,EAAM,cAAgB,QAAQ,UAAU,MAAM,KAAK,GACnD,MACF,IAAK,cACH,GAAI,EAAa,YAAa,WAAY,GAAQ,CAChD,EAAM,gBAAkB,KACxB,MAIJ,IAAK,oBAAqB,CACxB,MAAM,EAAQ,WAAW,GACzB,EAAM,sBAAwB,EAAa,EAAO,aAAc,GAChE,EAAM,yBAA2B,EAC/B,EACA,gBACA,GAEF,EAAM,gBAAkB,IACnB,IAAI,WAAW,IAEpB,MAEF,IAAK,SACL,IAAK,YACL,IAAK,aACL,IAAK,oBACL,IAAK,aACL,IAAK,cACL,IAAK,aACL,IAAK,cACL,IAAK,gBACL,IAAK,iBACL,IAAK,eACL,IAAK,eACL,IAAK,eACL,IAAK,WAAY,CACf,MAAM,EAAQ,WAAW,GACzB,EAAM,WAAa,EAAa,EAAO,aAAc,GACrD,EAAM,WAAa,EAAa,EAAO,aAAc,GACrD,EAAM,kBAAoB,EAAa,EAAO,SAAU,GACxD,MAEF,IAAK,oBACH,EAAM,MAAQ,EAAa,SAAS,SAAU,QAAS,GACvD,EAAM,OAAS,EAAa,SAAS,SAAU,SAAU,GACzD,EAAM,MAAQ,EAAa,SAAS,SAAU,QAAS,GACvD,EAAM,KAAO,EAAa,SAAS,SAAU,OAAQ,GACrD,EAAM,MAAQ,EAAa,SAAS,SAAU,QAAS,GACvD,EAAM,QAAU,EAAa,SAAS,SAAU,UAAW,GAC3D,EAAM,QAAU,EAAa,SAAS,SAAU,UAAW,GAC3D,EAAM,aAAe,EACnB,SAAS,SACT,eACA,GAEF,EAAM,aAAe,EACnB,SAAS,SACT,eACA,GAEF,EAAM,YAAc,EAAa,SAAS,SAAU,cAAe,GACnE,MACF,IAAK,mBACH,EAAM,iBAAmB,EACvB,SAAS,QACT,mBACA,GAEF,MACF,IAAK,qBACH,EAAM,SAAW,EAAa,SAAS,UAAW,aAAc,GAChE,EAAM,KAAO,EAAa,SAAS,UAAW,OAAQ,GACtD,EAAM,MAAQ,EAAa,SAAS,UAAW,QAAS,GACxD,EAAM,IAAM,EAAa,SAAS,UAAW,MAAO,GACpD,MACF,IAAK,yBACH,EAAM,SAAW,EAAa,SAAS,cAAe,aAAc,GACpE,EAAM,KAAO,EAAa,SAAS,cAAe,OAAQ,GAC1D,EAAM,MAAQ,EAAa,SAAS,cAAe,QAAS,GAC5D,EAAM,IAAM,EAAa,SAAS,cAAe,MAAO,GACxD,EAAM,KAAO,EAAa,SAAS,cAAe,OAAQ,GAC1D,EAAM,OAAS,EAAa,SAAS,cAAe,SAAU,GAC9D,EAAM,OAAS,EAAa,SAAS,cAAe,SAAU,GAC9D,EAAM,YAAc,EAClB,SAAS,cACT,cACA,GAEF,EAAM,YAAc,EAClB,SAAS,cACT,cACA,GAEF,EAAM,WAAa,EACjB,SAAS,cACT,aACA,GAEF,MACF,IAAK,yBACH,EAAM,SAAW,EAAa,SAAS,cAAe,aAAc,GACpE,EAAM,UAAY,EAAa,SAAS,cAAe,YAAa,GACpE,EAAM,IAAM,EAAa,SAAS,cAAe,MAAO,GACxD,MACF,IAAK,qBACH,EAAM,KAAO,EAAa,SAAS,UAAW,OAAQ,GACtD,EAAM,OAAS,EAAa,SAAS,UAAW,SAAU,GAC1D,EAAM,OAAS,EAAa,SAAS,UAAW,SAAU,GAC1D,EAAM,YAAc,EAAa,SAAS,UAAW,cAAe,GACpE,EAAM,YAAc,EAAa,SAAS,UAAW,cAAe,GACpE,EAAM,WAAa,EAAa,SAAS,UAAW,aAAc,GAClE,MACF,IAAK,0BACH,EAAM,SAAW,EACf,SAAS,eACT,aACA,GAEF,EAAM,KAAO,EAAa,SAAS,eAAgB,OAAQ,GAC3D,EAAM,MAAQ,EAAa,SAAS,eAAgB,QAAS,GAC7D,MACF,IAAK,yBACH,EAAM,SAAW,EAAa,SAAS,cAAe,aAAc,GACpE,EAAM,SAAW,EAAa,SAAS,cAAe,aAAc,GACpE,EAAM,iBAAmB,EACvB,SAAS,cACT,mBACA,GAKN,OAAO,GAGH,EAAA,CACJ,EACA,EACA,KAEA,IACE,IAAI,EAAqB,EAAI,UAC7B,EACA,EAAY,OAAO,eAAe,GAClC,CACA,MAAM,EAAa,OAAO,yBAAyB,EAAW,GAC9D,GAAI,EACF,OAAO,EAAW,IAAK,KAAK,KAoDlC,MAAM,EACJ,IAEA,QAAY,IAAR,EACF,OAGF,GAAmB,iBAAR,EACT,OAAO,EAGT,MAAM,EAAQ,OAAO,GACrB,OACE,OAAO,UAAU,IACjB,GAAS,GACT,GAAS,GAAK,GAAK,GACnB,OAAO,KAAW,EAEX,EAGF,GAGH,EAA2B,CAC/B,eACA,aACA,WACA,QACA,MACA"}

package/license

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 Tomer Aberbach
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and 
+associated documentation files (the "Software"), to deal in the Software without restriction, including 
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the 
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial 
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO 
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 
+USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "strict-diff",
+  "version": "0.0.1",
+  "author": {
+    "name": "Tomer Aberbach",
+    "email": "tomer@aberba.ch",
+    "url": "https://tomeraberba.ch"
+  },
+  "description": "Find any observable difference between two values.",
+  "keywords": [
+    "deep",
+    "diff",
+    "difference",
+    "equal",
+    "equals",
+    "equivalent",
+    "object",
+    "strict"
+  ],
+  "homepage": "https://github.com/TomerAberbach/strict-diff",
+  "repository": "TomerAberbach/strict-diff",
+  "bugs": {
+    "url": "https://github.com/TomerAberbach/strict-diff/issues"
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/TomerAberbach"
+  },
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">= 22"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "prettier": "@tomer/prettier-config",
+  "dependencies": {
+    "builtin-type": "^0.0.4"
+  },
+  "devDependencies": {
+    "@fast-check/vitest": "^0.3.0",
+    "@js-temporal/polyfill": "^0.5.1",
+    "@rollup/plugin-terser": "^1.0.0",
+    "@tomer/eslint-config": "^4.6.1",
+    "@tomer/prettier-config": "^4.0.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^9.39.2",
+    "jsdom": "^29.0.0",
+    "prettier": "^3.8.1",
+    "publint": "^0.3.18",
+    "rollup-plugin-tree-shakeable": "^2.0.0",
+    "tsdown": "^0.21.3",
+    "typescript": "^6.0.2",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "format": "prettier --cache --write .",
+    "lint": "eslint --cache --cache-location node_modules/.cache/eslint/ --fix .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "coverage": "vitest --coverage",
+    "bench": "vitest bench",
+    "build": "tsdown"
+  }
+}

package/readme.md

@@ -0,0 +1,117 @@
+<h1 align="center">
+  strict-diff
+</h1>
+
+<div align="center">
+  <a href="https://npmjs.org/package/strict-diff">
+    <img src="https://badgen.net/npm/v/strict-diff" alt="version" />
+  </a>
+  <a href="https://github.com/TomerAberbach/strict-diff/actions">
+    <img src="https://github.com/TomerAberbach/strict-diff/workflows/CI/badge.svg" alt="CI" />
+  </a>
+  <a href="https://unpkg.com/strict-diff/dist/index.js">
+    <img src="https://deno.bundlejs.com/?q=strict-diff&badge" alt="gzip size" />
+  </a>
+  <a href="https://unpkg.com/strict-diff/dist/index.js">
+    <img src="https://deno.bundlejs.com/?q=strict-diff&config={%22compression%22:{%22type%22:%22brotli%22}}&badge" alt="brotli size" />
+  </a>
+  <a href="https://github.com/sponsors/TomerAberbach">
+    <img src="https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&color=%23fe8e86" alt="Sponsor" />
+  </a>
+</div>
+
+<div align="center">
+  Find any observable difference between two values.
+</div>
+
+## Features
+
+- **Strict:** Finds the most minuscule differences between values.
+- **Structured:** Each diff has a structured path to the diff
+- **Lazy:** Returns a lazy iterable over the diffs
+
+## Install
+
+```sh
+$ npm i strict-diff
+```
+
+## Usage
+
+```js
+import strictDiff from 'strict-diff'
+
+// Primitive value diff
+console.log([...strictDiff(1, 2)])
+//=> [{ kind: 'value', path: [], left: 1, right: 2 }]
+
+// Type diff
+console.log([...strictDiff(null, undefined)])
+//=> [{ kind: 'type', path: [], left: 'null', right: 'undefined' }]
+
+// Object property value diff
+console.log([...strictDiff({ a: 1 }, { a: 2 })])
+//=> [
+//     {
+//       kind: 'value',
+//       path: [
+//         { kind: 'property', index: 0, key: 'a' },
+//         { kind: 'internal-slot', slot: 'Value' },
+//       ],
+//       left: 1,
+//       right: 2,
+//     },
+//   ]
+
+// Object key diff
+console.log([...strictDiff({ a: 1 }, { b: 1 })])
+//=> [{ kind: 'key', path: [], index: 0, left: 'a', right: 'b' }]
+
+// Property descriptor diff (non-writable vs writable)
+const left = Object.defineProperty({}, `a`, {
+  value: 1,
+  writable: false,
+  enumerable: true,
+  configurable: true,
+})
+console.log([...strictDiff(left, { a: 1 })])
+//=> [
+//     {
+//       kind: 'value',
+//       path: [
+//         { kind: 'property', index: 0, key: 'a' },
+//         { kind: 'internal-slot', slot: 'Writable' },
+//       ],
+//       left: false,
+//       right: true,
+//     },
+//   ]
+
+// Lazily iterated
+const diffs = strictDiff({ a: 1, b: 2 }, { a: 99, b: 99 })
+const [firstDiff] = diffs
+console.log(firstDiff)
+//=> {
+//     kind: 'value',
+//     path: [
+//       { kind: 'property', index: 0, key: 'a' },
+//       { kind: 'internal-slot', slot: 'Value' },
+//     ],
+//     left: 1,
+//     right: 99,
+//   }
+```
+
+See [the tests](./src/index.test.ts) for other example diffs.
+
+## Contributing
+
+Stars are always welcome!
+
+For bugs and feature requests,
+[please create an issue](https://github.com/TomerAberbach/strict-diff/issues/new).
+
+## License
+
+[MIT](https://github.com/TomerAberbach/strict-diff/blob/main/license) ©
+[Tomer Aberbach](https://github.com/TomerAberbach)