@gjsify/assert 0.0.4 → 0.1.0

package/README.md

@@ -1,7 +1,31 @@
 # @gjsify/assert
 
-Node.js assert module for Gjs
+GJS implementation of the Node.js `assert` module. Provides assertion functions for testing including deepEqual, throws, and strict mode.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/assert
+# or
+yarn add @gjsify/assert
+```
+
+## Usage
+
+```typescript
+import { strictEqual, deepStrictEqual, throws } from '@gjsify/assert';
+
+strictEqual(1 + 1, 2);
+deepStrictEqual({ a: 1 }, { a: 1 });
+throws(() => { throw new Error('fail'); });
+```
 
 ## Inspirations and credits
+
 - https://deno.land/std/node/assert.ts
 
+## License
+
+MIT

package/cjs-compat.cjs

@@ -0,0 +1,6 @@
+// CJS compatibility wrapper for npm packages that require('assert')
+// In Node.js CJS, require('assert') returns the assert function directly.
+// When esbuild bundles ESM @gjsify/assert for CJS consumers, it returns a
+// namespace object instead. This wrapper extracts the default export.
+const mod = require('./lib/esm/index.js');
+module.exports = mod.default || mod;

package/lib/esm/assertion-error.js

@@ -0,0 +1,71 @@
+import { safeInspect } from "./inspect-fallback.js";
+class AssertionError extends Error {
+  actual;
+  expected;
+  operator;
+  code;
+  generatedMessage;
+  constructor(options) {
+    const {
+      actual,
+      expected,
+      operator = "fail",
+      stackStartFn
+    } = options;
+    const isGenerated = options.message == null;
+    const message = isGenerated ? generateMessage(actual, expected, operator) : String(options.message);
+    super(message);
+    this.name = "AssertionError";
+    this.code = "ERR_ASSERTION";
+    this.actual = actual;
+    this.expected = expected;
+    this.operator = operator;
+    this.generatedMessage = isGenerated;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, stackStartFn || this.constructor);
+    }
+  }
+  toString() {
+    return `${this.name} [${this.code}]: ${this.message}`;
+  }
+  // Support for util.inspect and console.log
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](_depth, _options) {
+    return this.toString();
+  }
+}
+const kReadableOperator = {
+  "deepStrictEqual": "Expected values to be strictly deep-equal:",
+  "strictEqual": "Expected values to be strictly equal:",
+  "strictEqualObject": 'Expected "actual" to be reference-equal to "expected":',
+  "deepEqual": "Expected values to be loosely deep-equal:",
+  "notDeepStrictEqual": 'Expected "actual" not to be strictly deep-equal to:',
+  "notStrictEqual": 'Expected "actual" to be strictly unequal to:',
+  "notStrictEqualObject": 'Expected "actual" not to be reference-equal to "expected":',
+  "notDeepEqual": 'Expected "actual" not to be loosely deep-equal to:',
+  "notIdentical": "Values have same structure but are not reference-equal:",
+  "notEqual": 'Expected "actual" to be loosely unequal to:',
+  "equal": "Expected values to be loosely equal:",
+  "==": "Expected values to be loosely equal:",
+  "!=": 'Expected "actual" to be loosely unequal to:',
+  "===": "Expected values to be strictly equal:",
+  "!==": 'Expected "actual" to be strictly unequal to:',
+  "fail": "Failed"
+};
+function generateMessage(actual, expected, operator) {
+  const header = kReadableOperator[operator] || `Operator: ${operator}`;
+  if (operator === "fail") {
+    return "Failed";
+  }
+  const actualStr = safeInspect(actual);
+  const expectedStr = safeInspect(expected);
+  return `${header}
+
++ actual - expected
+
++ ${actualStr}
+- ${expectedStr}
+`;
+}
+export {
+  AssertionError
+};

package/lib/esm/deep-equal.js

@@ -0,0 +1,525 @@
+var ValueType = /* @__PURE__ */ ((ValueType2) => {
+  ValueType2[ValueType2["noIterator"] = 0] = "noIterator";
+  ValueType2[ValueType2["isArray"] = 1] = "isArray";
+  ValueType2[ValueType2["isSet"] = 2] = "isSet";
+  ValueType2[ValueType2["isMap"] = 3] = "isMap";
+  return ValueType2;
+})(ValueType || {});
+const kStrict = 1;
+const kLoose = 0;
+function isDate(v) {
+  return v instanceof Date;
+}
+function isRegExp(v) {
+  return v instanceof RegExp;
+}
+function isMap(v) {
+  return v instanceof Map;
+}
+function isSet(v) {
+  return v instanceof Set;
+}
+function isError(v) {
+  return v instanceof Error;
+}
+function isAnyArrayBuffer(v) {
+  return v instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && v instanceof SharedArrayBuffer;
+}
+function isArrayBufferView(v) {
+  return ArrayBuffer.isView(v);
+}
+function isBoxedPrimitive(v) {
+  return v instanceof Number || v instanceof String || v instanceof Boolean || v instanceof BigInt || v instanceof Symbol;
+}
+function isNumberObject(v) {
+  return v instanceof Number;
+}
+function isStringObject(v) {
+  return v instanceof String;
+}
+function isBooleanObject(v) {
+  return v instanceof Boolean;
+}
+function isBigIntObject(v) {
+  return typeof BigInt !== "undefined" && v instanceof Object && Object.prototype.toString.call(v) === "[object BigInt]";
+}
+function isSymbolObject(v) {
+  return v instanceof Object && Object.prototype.toString.call(v) === "[object Symbol]";
+}
+function isFloatTypedArray(v) {
+  return v instanceof Float32Array || v instanceof Float64Array;
+}
+const hasOwn = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+const hasEnumerable = (obj, prop) => Object.prototype.propertyIsEnumerable.call(obj, prop);
+const wellKnownConstructors = /* @__PURE__ */ new Set([
+  Array,
+  ArrayBuffer,
+  Boolean,
+  DataView,
+  Date,
+  Error,
+  Float32Array,
+  Float64Array,
+  Function,
+  Int8Array,
+  Int16Array,
+  Int32Array,
+  Map,
+  Number,
+  Object,
+  Promise,
+  RegExp,
+  Set,
+  String,
+  Symbol,
+  Uint8Array,
+  Uint16Array,
+  Uint32Array,
+  Uint8ClampedArray,
+  BigInt64Array,
+  BigUint64Array,
+  WeakMap,
+  WeakSet
+]);
+function getOwnNonIndexProperties(obj, skipSymbols) {
+  const keys = Object.getOwnPropertyNames(obj);
+  const result = [];
+  for (const key of keys) {
+    const num = Number(key);
+    if (Number.isInteger(num) && num >= 0 && num < 2 ** 32 - 1 && String(num) === key) {
+      continue;
+    }
+    if (!hasEnumerable(obj, key)) {
+      continue;
+    }
+    result.push(key);
+  }
+  if (!skipSymbols) {
+    const symbols = Object.getOwnPropertySymbols(obj);
+    for (const sym of symbols) {
+      if (hasEnumerable(obj, sym)) {
+        result.push(sym);
+      }
+    }
+  }
+  return result;
+}
+function areSimilarRegExps(a, b) {
+  return a.source === b.source && a.flags === b.flags && a.lastIndex === b.lastIndex;
+}
+function areSimilarFloatArrays(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  const viewA = a;
+  const viewB = b;
+  for (let i = 0; i < viewA.length; i++) {
+    if (viewA[i] !== viewB[i]) return false;
+  }
+  return true;
+}
+function areSimilarTypedArrays(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  const viewA = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
+  const viewB = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
+  for (let i = 0; i < viewA.length; i++) {
+    if (viewA[i] !== viewB[i]) return false;
+  }
+  return true;
+}
+function areEqualArrayBuffers(buf1, buf2) {
+  if (buf1.byteLength !== buf2.byteLength) return false;
+  const a = new Uint8Array(buf1);
+  const b = new Uint8Array(buf2);
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function isEqualBoxedPrimitive(val1, val2) {
+  if (isNumberObject(val1)) {
+    return isNumberObject(val2) && Object.is(val1.valueOf(), val2.valueOf());
+  }
+  if (isStringObject(val1)) {
+    return isStringObject(val2) && val1.valueOf() === val2.valueOf();
+  }
+  if (isBooleanObject(val1)) {
+    return isBooleanObject(val2) && val1.valueOf() === val2.valueOf();
+  }
+  if (isBigIntObject(val1)) {
+    return isBigIntObject(val2) && val1[Symbol.toPrimitive]("number") === val2[Symbol.toPrimitive]("number");
+  }
+  if (isSymbolObject(val1)) {
+    return isSymbolObject(val2) && Symbol.prototype.valueOf.call(val1) === Symbol.prototype.valueOf.call(val2);
+  }
+  return false;
+}
+function getTypedArrayTag(val) {
+  return Object.prototype.toString.call(val).slice(8, -1);
+}
+function innerDeepEqual(val1, val2, mode, memos) {
+  if (val1 === val2) {
+    return val1 !== 0 || Object.is(val1, val2) || mode === kLoose;
+  }
+  if (mode !== kLoose) {
+    if (typeof val1 === "number") {
+      return val1 !== val1 && val2 !== val2;
+    }
+    if (typeof val2 !== "object" || typeof val1 !== "object" || val1 === null || val2 === null) {
+      return false;
+    }
+  } else {
+    if (val1 === null || typeof val1 !== "object") {
+      return (val2 === null || typeof val2 !== "object") && // eslint-disable-next-line eqeqeq
+      (val1 == val2 || val1 !== val1 && val2 !== val2);
+    }
+    if (val2 === null || typeof val2 !== "object") {
+      return false;
+    }
+  }
+  return objectComparisonStart(val1, val2, mode, memos);
+}
+function objectComparisonStart(val1, val2, mode, memos) {
+  if (mode === kStrict) {
+    if (wellKnownConstructors.has(val1.constructor) || val1.constructor !== void 0 && !hasOwn(val1, "constructor")) {
+      if (val1.constructor !== val2.constructor) {
+        return false;
+      }
+    } else if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
+      return false;
+    }
+  }
+  const val1Tag = Object.prototype.toString.call(val1);
+  const val2Tag = Object.prototype.toString.call(val2);
+  if (val1Tag !== val2Tag) {
+    return false;
+  }
+  if (Array.isArray(val1)) {
+    if (!Array.isArray(val2) || val1.length !== val2.length) {
+      return false;
+    }
+    const keys2 = getOwnNonIndexProperties(val2, mode === kLoose);
+    if (keys2.length !== getOwnNonIndexProperties(val1, mode === kLoose).length) {
+      return false;
+    }
+    return keyCheck(val1, val2, mode, memos, 1 /* isArray */, keys2);
+  } else if (val1Tag === "[object Object]") {
+    return keyCheck(val1, val2, mode, memos, 0 /* noIterator */);
+  } else if (isDate(val1)) {
+    if (!isDate(val2)) return false;
+    const time1 = val1.getTime();
+    const time2 = val2.getTime();
+    if (time1 !== time2 && !(Number.isNaN(time1) && Number.isNaN(time2))) {
+      return false;
+    }
+  } else if (isRegExp(val1)) {
+    if (!isRegExp(val2) || !areSimilarRegExps(val1, val2)) {
+      return false;
+    }
+  } else if (isArrayBufferView(val1)) {
+    if (getTypedArrayTag(val1) !== getTypedArrayTag(val2)) {
+      return false;
+    }
+    if (mode === kLoose && isFloatTypedArray(val1)) {
+      if (!areSimilarFloatArrays(val1, val2)) {
+        return false;
+      }
+    } else if (!areSimilarTypedArrays(val1, val2)) {
+      return false;
+    }
+    const keys2 = getOwnNonIndexProperties(val2, mode === kLoose);
+    if (keys2.length !== getOwnNonIndexProperties(val1, mode === kLoose).length) {
+      return false;
+    }
+    return keyCheck(val1, val2, mode, memos, 0 /* noIterator */, keys2);
+  } else if (isSet(val1)) {
+    if (!isSet(val2) || val1.size !== val2.size) {
+      return false;
+    }
+    return keyCheck(val1, val2, mode, memos, 2 /* isSet */);
+  } else if (isMap(val1)) {
+    if (!isMap(val2) || val1.size !== val2.size) {
+      return false;
+    }
+    return keyCheck(val1, val2, mode, memos, 3 /* isMap */);
+  } else if (isAnyArrayBuffer(val1)) {
+    if (!isAnyArrayBuffer(val2) || !areEqualArrayBuffers(val1, val2)) {
+      return false;
+    }
+  } else if (isError(val1)) {
+    if (!isError(val2) || val1.message !== val2.message || val1.name !== val2.name) {
+      return false;
+    }
+    if (hasOwn(val1, "cause") !== hasOwn(val2, "cause")) {
+      return false;
+    }
+    if (hasOwn(val1, "cause") && !innerDeepEqual(val1.cause, val2.cause, mode, memos)) {
+      return false;
+    }
+  } else if (isBoxedPrimitive(val1)) {
+    if (!isEqualBoxedPrimitive(val1, val2)) {
+      return false;
+    }
+  } else if (Array.isArray(val2) || isArrayBufferView(val2) || isSet(val2) || isMap(val2) || isDate(val2) || isRegExp(val2) || isAnyArrayBuffer(val2) || isBoxedPrimitive(val2) || isError(val2)) {
+    return false;
+  }
+  return keyCheck(val1, val2, mode, memos, 0 /* noIterator */);
+}
+function getEnumerables(val, keys) {
+  return keys.filter((key) => hasEnumerable(val, key));
+}
+function keyCheck(val1, val2, mode, memos, iterationType, keys2) {
+  const isArrayLikeObject = keys2 !== void 0;
+  if (keys2 === void 0) {
+    keys2 = Object.keys(val2);
+  }
+  let keys1;
+  if (!isArrayLikeObject) {
+    if (keys2.length !== (keys1 = Object.keys(val1)).length) {
+      return false;
+    } else if (mode === kStrict) {
+      const symbolKeysA = Object.getOwnPropertySymbols(val1);
+      if (symbolKeysA.length !== 0) {
+        let count = 0;
+        for (const key of symbolKeysA) {
+          if (hasEnumerable(val1, key)) {
+            if (!hasEnumerable(val2, key)) return false;
+            keys2.push(key);
+            count++;
+          } else if (hasEnumerable(val2, key)) {
+            return false;
+          }
+        }
+        const symbolKeysB = Object.getOwnPropertySymbols(val2);
+        if (symbolKeysA.length !== symbolKeysB.length && getEnumerables(val2, symbolKeysB).length !== count) {
+          return false;
+        }
+      } else {
+        const symbolKeysB = Object.getOwnPropertySymbols(val2);
+        if (symbolKeysB.length !== 0 && getEnumerables(val2, symbolKeysB).length !== 0) {
+          return false;
+        }
+      }
+    }
+  }
+  if (keys2.length === 0 && (iterationType === 0 /* noIterator */ || iterationType === 1 /* isArray */ && val2.length === 0 || val2.size === 0)) {
+    return true;
+  }
+  if (memos === null) {
+    return objEquiv(val1, val2, mode, keys1, keys2, memos, iterationType);
+  }
+  return handleCycles(val1, val2, mode, keys1, keys2, memos, iterationType);
+}
+function handleCycles(val1, val2, mode, keys1, keys2, memos, iterationType) {
+  if (memos === void 0) {
+    memos = {
+      set: void 0,
+      a: val1,
+      b: val2,
+      c: void 0,
+      d: void 0,
+      deep: false
+    };
+    return objEquiv(val1, val2, mode, keys1, keys2, memos, iterationType);
+  }
+  if (memos.set === void 0) {
+    if (memos.deep === false) {
+      if (memos.a === val1) return memos.b === val2;
+      if (memos.b === val2) return false;
+      memos.c = val1;
+      memos.d = val2;
+      memos.deep = true;
+      const result = objEquiv(val1, val2, mode, keys1, keys2, memos, iterationType);
+      memos.deep = false;
+      return result;
+    }
+    memos.set = /* @__PURE__ */ new Set();
+    memos.set.add(memos.a);
+    memos.set.add(memos.b);
+    memos.set.add(memos.c);
+    memos.set.add(memos.d);
+  }
+  const { set } = memos;
+  const originalSize = set.size;
+  set.add(val1);
+  set.add(val2);
+  if (originalSize !== set.size - 2) {
+    return originalSize === set.size;
+  }
+  const areEq = objEquiv(val1, val2, mode, keys1, keys2, memos, iterationType);
+  set.delete(val1);
+  set.delete(val2);
+  return areEq;
+}
+function findLooseMatchingPrimitives(prim) {
+  switch (typeof prim) {
+    case "undefined":
+      return null;
+    case "object":
+      return void 0;
+    case "symbol":
+      return false;
+    case "string":
+      prim = +prim;
+    // falls through
+    case "number":
+      if (prim !== prim) return false;
+  }
+  return true;
+}
+function setMightHaveLoosePrim(a, b, prim) {
+  const altValue = findLooseMatchingPrimitives(prim);
+  if (altValue != null) return altValue;
+  return !b.has(altValue) && a.has(altValue);
+}
+function mapMightHaveLoosePrim(a, b, prim, item2, memo) {
+  const altValue = findLooseMatchingPrimitives(prim);
+  if (altValue != null) return altValue;
+  const item1 = a.get(altValue);
+  if (item1 === void 0 && !a.has(altValue) || !innerDeepEqual(item1, item2, kLoose, memo)) {
+    return false;
+  }
+  return !b.has(altValue) && innerDeepEqual(item1, item2, kLoose, memo);
+}
+function setEquiv(a, b, mode, memo) {
+  let array;
+  for (const val of b) {
+    if (!a.has(val)) {
+      if ((typeof val !== "object" || val === null) && (mode !== kLoose || !setMightHaveLoosePrim(a, b, val))) {
+        return false;
+      }
+      if (array === void 0) array = [];
+      array.push(val);
+    }
+  }
+  if (array === void 0) return true;
+  for (const val1 of a) {
+    if (typeof val1 === "object" && val1 !== null) {
+      if (!b.has(val1)) {
+        let found = false;
+        for (let i = 0; i < array.length; i++) {
+          if (innerDeepEqual(val1, array[i], mode, memo)) {
+            array.splice(i, 1);
+            found = true;
+            break;
+          }
+        }
+        if (!found) return false;
+      }
+    } else if (!b.has(val1) && (mode !== kLoose || !setMightHaveLoosePrim(b, a, val1))) {
+      let found = false;
+      for (let i = 0; i < array.length; i++) {
+        if (innerDeepEqual(val1, array[i], mode, memo)) {
+          array.splice(i, 1);
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+  }
+  return array.length === 0;
+}
+function mapEquiv(a, b, mode, memo) {
+  let array;
+  for (const [key2, item2] of b) {
+    if (typeof key2 === "object" && key2 !== null) {
+      if (array === void 0) {
+        if (a.size === 1) {
+          const [key1, item1] = a.entries().next().value;
+          return innerDeepEqual(key1, key2, mode, memo) && innerDeepEqual(item1, item2, mode, memo);
+        }
+        array = [];
+      }
+      array.push(key2);
+    } else {
+      const item1 = a.get(key2);
+      if (item1 === void 0 && !a.has(key2) || !innerDeepEqual(item1, item2, mode, memo)) {
+        if (mode !== kLoose) return false;
+        if (!mapMightHaveLoosePrim(a, b, key2, item2, memo)) return false;
+        if (array === void 0) array = [];
+        array.push(key2);
+      }
+    }
+  }
+  if (array === void 0) return true;
+  for (const [key1, item1] of a) {
+    if (typeof key1 === "object" && key1 !== null) {
+      if (!b.has(key1)) {
+        let found = false;
+        for (let i = 0; i < array.length; i++) {
+          const key2 = array[i];
+          if (innerDeepEqual(key1, key2, mode, memo) && innerDeepEqual(item1, b.get(key2), mode, memo)) {
+            array.splice(i, 1);
+            found = true;
+            break;
+          }
+        }
+        if (!found) return false;
+      }
+    } else if (mode === kLoose && typeof key1 !== "object" && (!a.has(key1) || !innerDeepEqual(item1, a.get(key1), mode, memo))) {
+    }
+  }
+  return array.length === 0;
+}
+function objEquiv(a, b, mode, keys1, keys2, memos, iterationType) {
+  if (keys2.length > 0) {
+    const aRec = a;
+    const bRec = b;
+    let i = 0;
+    if (keys1 !== void 0) {
+      for (; i < keys2.length; i++) {
+        const key = keys2[i];
+        if (keys1[i] !== key) break;
+        if (!innerDeepEqual(aRec[key], bRec[key], mode, memos)) return false;
+      }
+    }
+    for (; i < keys2.length; i++) {
+      const key = keys2[i];
+      const descriptor = Object.getOwnPropertyDescriptor(a, key);
+      if (!descriptor?.enumerable || !innerDeepEqual(
+        descriptor.value !== void 0 ? descriptor.value : aRec[key],
+        bRec[key],
+        mode,
+        memos
+      )) {
+        return false;
+      }
+    }
+  }
+  if (iterationType === 1 /* isArray */) {
+    const aArr = a;
+    const bArr = b;
+    for (let i = 0; i < aArr.length; i++) {
+      if (bArr[i] === void 0 && !hasOwn(b, i)) {
+        if (aArr[i] !== void 0 || hasOwn(a, i)) return false;
+        continue;
+      }
+      if (mode !== kLoose && aArr[i] === void 0 && !hasOwn(a, i)) {
+        return false;
+      }
+      if (!innerDeepEqual(aArr[i], bArr[i], mode, memos)) return false;
+    }
+  } else if (iterationType === 2 /* isSet */) {
+    if (!setEquiv(a, b, mode, memos)) return false;
+  } else if (iterationType === 3 /* isMap */) {
+    if (!mapEquiv(a, b, mode, memos)) return false;
+  }
+  return true;
+}
+let detectCycles = function(val1, val2, mode) {
+  try {
+    return innerDeepEqual(val1, val2, mode, null);
+  } catch {
+    detectCycles = (v1, v2, m) => innerDeepEqual(v1, v2, m, void 0);
+    return innerDeepEqual(val1, val2, mode, void 0);
+  }
+};
+function isDeepEqual(val1, val2) {
+  return detectCycles(val1, val2, kLoose);
+}
+function isDeepStrictEqual(val1, val2) {
+  return detectCycles(val1, val2, kStrict);
+}
+export {
+  isDeepEqual,
+  isDeepStrictEqual
+};