porffor 0.55.27 → 0.55.31

package/r.cjs

@@ -1,8 +1,257 @@
-function foo() {
-  return this;
+Foo.prototype.baz = function baz() {};
+
+function Foo() {
+  this.bar = 1;
 }
 
-console.log(foo());
+Foo.prototype.bar = function bar() {};
+
+
+
+// var EQUAL = 1;
+// var NOT_EQUAL = -1;
+// var UNKNOWN = 0;
+
+// function setCache(cache, left, right, result) {
+//   var otherCache;
+
+//   otherCache = cache.get(left);
+//   if (!otherCache) cache.set(left, otherCache = new Map());
+//   otherCache.set(right, result);
+
+//   otherCache = cache.get(right);
+//   if (!otherCache) cache.set(right, otherCache = new Map());
+//   otherCache.set(left, result);
+// }
+
+// function getCache(cache, left, right) {
+//   var otherCache;
+//   var result;
+
+//   otherCache = cache.get(left);
+//   result = otherCache && otherCache.get(right);
+//   if (result) return result;
+
+//   otherCache = cache.get(right);
+//   result = otherCache && otherCache.get(left);
+//   if (result) return result;
+
+//   return UNKNOWN;
+// }
+
+// function cacheComparison(a, b, compare, cache) {
+//   var result = compare(a, b, cache);
+//   if (cache && (result === EQUAL || result === NOT_EQUAL)) {
+//     setCache(cache, a, b, result);
+//   }
+//   return result;
+// }
+
+// function isBoxed(value) {
+//   return value instanceof String
+//     || value instanceof Number
+//     || value instanceof Boolean
+//     || value instanceof Symbol;
+// }
+
+// function fail() {
+//   return NOT_EQUAL;
+// }
+
+// function compareIf(a, b, test, compare, cache) {
+//   return !test(a)
+//     ? !test(b) ? UNKNOWN : NOT_EQUAL
+//     : !test(b) ? NOT_EQUAL : cacheComparison(a, b, compare, cache);
+// }
+
+// function compareEquality(a, b, cache) {
+//   return compareIf(a, b, isOptional, compareOptionality)
+//     || compareIf(a, b, isPrimitiveEquatable, comparePrimitiveEquality)
+//     || compareIf(a, b, isObjectEquatable, compareObjectEquality, cache)
+//     || NOT_EQUAL;
+// }
+
+// function tryCompareStrictEquality(a, b) {
+//   return a === b ? EQUAL : UNKNOWN;
+// }
+
+// function tryCompareTypeOfEquality(a, b) {
+//   return typeof a !== typeof b ? NOT_EQUAL : UNKNOWN;
+// }
+
+// function tryCompareToStringTagEquality(a, b) {
+//   var aTag = Symbol.toStringTag in a ? a[Symbol.toStringTag] : undefined;
+//   var bTag = Symbol.toStringTag in b ? b[Symbol.toStringTag] : undefined;
+//   return aTag !== bTag ? NOT_EQUAL : UNKNOWN;
+// }
+
+// function isOptional(value) {
+//   return value === undefined
+//     || value === null;
+// }
+
+// function compareOptionality(a, b) {
+//   return tryCompareStrictEquality(a, b)
+//     || NOT_EQUAL;
+// }
+
+// function isPrimitiveEquatable(value) {
+//   switch (typeof value) {
+//     case 'string':
+//     case 'number':
+//     case 'boolean':
+//     case 'symbol':
+//       return true;
+//     default:
+//       return isBoxed(value);
+//   }
+// }
+
+// function comparePrimitiveEquality(a, b) {
+//   if (isBoxed(a)) a = a.valueOf();
+//   if (isBoxed(b)) b = b.valueOf();
+
+//   return tryCompareStrictEquality(a, b)
+//     || tryCompareTypeOfEquality(a, b)
+//     || compareIf(a, b, isNaNEquatable, compareNaNEquality)
+//     || NOT_EQUAL;
+// }
+
+// function isNaNEquatable(value) {
+//   return typeof value === 'number';
+// }
+
+// function compareNaNEquality(a, b) {
+//   return isNaN(a) && isNaN(b) ? EQUAL : NOT_EQUAL;
+// }
+
+// function isObjectEquatable(value) {
+//   return typeof value === 'object';
+// }
+
+// function compareObjectEquality(a, b, cache) {
+//   if (!cache) cache = new Map();
+
+//   return getCache(cache, a, b)
+//     || setCache(cache, a, b, EQUAL) // consider equal for now
+//     || cacheComparison(a, b, tryCompareStrictEquality, cache)
+//     || cacheComparison(a, b, tryCompareToStringTagEquality, cache)
+//     || compareIf(a, b, isValueOfEquatable, compareValueOfEquality)
+//     || compareIf(a, b, isToStringEquatable, compareToStringEquality)
+//     || compareIf(a, b, isArrayLikeEquatable, compareArrayLikeEquality, cache)
+//     || compareIf(a, b, isStructurallyEquatable, compareStructuralEquality, cache)
+//     || compareIf(a, b, isIterableEquatable, compareIterableEquality, cache)
+//     || cacheComparison(a, b, fail, cache);
+// }
+
+// function isValueOfEquatable(value) {
+//   return value instanceof Date;
+// }
+
+// function compareValueOfEquality(a, b) {
+//   return compareIf(a.valueOf(), b.valueOf(), isPrimitiveEquatable, comparePrimitiveEquality)
+//     || NOT_EQUAL;
+// }
+
+// function isToStringEquatable(value) {
+//   return value instanceof RegExp;
+// }
+
+// function compareToStringEquality(a, b) {
+//   return compareIf(a.toString(), b.toString(), isPrimitiveEquatable, comparePrimitiveEquality)
+//     || NOT_EQUAL;
+// }
+
+// function isArrayLikeEquatable(value) {
+//   return Array.isArray(value)
+//     || value instanceof Uint8Array
+//     || value instanceof Uint8ClampedArray
+//     || value instanceof Uint16Array
+//     || value instanceof Uint32Array
+//     || value instanceof Int8Array
+//     || value instanceof Int16Array
+//     || value instanceof Int32Array
+//     || value instanceof Float32Array
+//     || value instanceof Float64Array;
+// }
+
+// function compareArrayLikeEquality(a, b, cache) {
+//   if (a.length !== b.length) return NOT_EQUAL;
+//   for (var i = 0; i < a.length; i++) {
+//     if (compareEquality(a[i], b[i], cache) === NOT_EQUAL) {
+//       return NOT_EQUAL;
+//     }
+//   }
+//   return EQUAL;
+// }
+
+// function isStructurallyEquatable(value) {
+//   return !(value instanceof Promise // only comparable by reference
+//     || value instanceof WeakMap // only comparable by reference
+//     || value instanceof WeakSet // only comparable by reference
+//     || value instanceof Map // comparable via @@iterator
+//     || value instanceof Set); // comparable via @@iterator
+// }
+
+// function compareStructuralEquality(a, b, cache) {
+//   var aKeys = [];
+//   for (var key in a) aKeys.push(key);
+
+//   var bKeys = [];
+//   for (var key in b) bKeys.push(key);
+
+//   if (aKeys.length !== bKeys.length) {
+//     return NOT_EQUAL;
+//   }
+
+//   aKeys.sort();
+//   bKeys.sort();
+
+//   for (var i = 0; i < aKeys.length; i++) {
+//     var aKey = aKeys[i];
+//     var bKey = bKeys[i];
+//     if (compareEquality(aKey, bKey, cache) === NOT_EQUAL) {
+//       return NOT_EQUAL;
+//     }
+//     if (compareEquality(a[aKey], b[bKey], cache) === NOT_EQUAL) {
+//       return NOT_EQUAL;
+//     }
+//   }
+
+//   return EQUAL;
+// }
+
+// // hack: do iterables via for..of
+// function isIterableEquatable(value) {
+//   try {
+//     for (const _ of value) { break; }
+//     return true;
+//   } catch {
+//     return false;
+//   }
+// }
+
+// function compareIterableEquality(a, b, cache) {
+//   let aValues = [];
+//   for (const x of a) aValues.push(x);
+
+//   let bValues = [];
+//   for (const x of b) bValues.push(x);
+
+//   return compareArrayLikeEquality(aValues, bValues, cache);
+// }
+
+// var __assert_deepEqual__compare = (a, b) => {
+//   return compareEquality(a, b) === EQUAL;
+// };
+
+// var __assert_deepEqual = (actual, expected) => {
+//   if (!assert.deepEqual._compare(actual, expected)) {
+//     throw new Test262Error('assert.deepEqual failed');
+//   }
+// };
+
+// __assert_deepEqual([], []);
 
 // let x = {};
 // x.__proto__ = { wow() { console.log(0); } };

package/runner/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.55.27';
+globalThis.version = '0.55.31';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {