porffor 0.56.3 → 0.56.5

package/compiler/codegen.js

@@ -6320,6 +6320,12 @@ const generateTaggedTemplate = (scope, decl, global = false, name = undefined, v
       return out;
     },
 
+    __Porffor_c: str => {
+      return [
+        [ null, 'c', str ]
+      ];
+    },
+
     __Porffor_bs: str => makeString(scope, str, true),
     __Porffor_s: str => makeString(scope, str, false)
   };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.56.3",
+  "version": "0.56.5",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/r.cjs

@@ -1,16 +1,109 @@
-class C {
-  // static #method = () => 1;
-  static #method() {
-    return 'Test262';
+var assert = mustBeTrue => {
+  if (mustBeTrue === true) {
+    return;
   }
 
-  static getPrivateMethod() {
-    this.#method = () => 2;
-    return this.#method();
+  throw new Test262Error('assert failed');
+};
+assert; // idk why exactly but this fixes many tests by forcing indirect ref
+
+var __assert_throws = (expectedErrorConstructor, func) => {
+  if (typeof func !== 'function') {
+    throw new Test262Error('assert.throws invoked with a non-function value');
+  }
+
+  try {
+    func();
+  } catch {
+    return;
+  }
+
+  throw new Test262Error('assert.throws failed');
+};
+
+var __assert__isSameValue = (a, b) => {
+  if (a === b) {
+    // Handle +/-0 vs. -/+0
+    return a !== 0 || 1 / a === 1 / b;
+  }
+
+  // Handle NaN vs. NaN
+  return a !== a && b !== b;
+};
+
+var __assert_sameValue = (actual, expected) => {
+  if (assert._isSameValue(actual, expected)) {
+    return;
+  }
+
+  throw new Test262Error('assert.sameValue failed');
+};
+
+var __assert_notSameValue = (actual, unexpected) => {
+  if (!assert._isSameValue(actual, unexpected)) {
+    return;
+  }
+
+  throw new Test262Error('assert.notSameValue failed');
+};
+
+var typedArrayConstructors = [
+  Float64Array,
+  Float32Array,
+  Int32Array,
+  Int16Array,
+  Int8Array,
+  Uint32Array,
+  Uint16Array,
+  Uint8Array,
+  Uint8ClampedArray
+];
+
+function testWithTypedArrayConstructors(f, selected) {
+  var constructors = selected || typedArrayConstructors;
+  for (var i = 0; i < constructors.length; ++i) {
+    f(constructors[i]);
   }
 }
 
-console.log(C.getPrivateMethod())
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
+
+  function testRes(result, msg) {
+    assert.sameValue(result.length, 4, msg);
+    assert.sameValue(result[0], 40, msg + " & result[0] === 40");
+    assert.sameValue(result[1], 41, msg + " & result[1] === 41");
+    assert.sameValue(result[2], 42, msg + " & result[2] === 42");
+    assert.sameValue(result[3], 43, msg + " & result[3] === 43");
+  }
+
+  testRes(sample.subarray(0), "begin == 0");
+  testRes(sample.subarray(-4), "begin == -srcLength");
+  testRes(sample.subarray(-5), "begin < -srcLength");
+
+  testRes(sample.subarray(0, 4), "begin == 0, end == srcLength");
+  testRes(sample.subarray(-4, 4), "begin == -srcLength, end == srcLength");
+  testRes(sample.subarray(-5, 4), "begin < -srcLength, end == srcLength");
+
+  testRes(sample.subarray(0, 5), "begin == 0, end > srcLength");
+  testRes(sample.subarray(-4, 5), "begin == -srcLength, end > srcLength");
+  testRes(sample.subarray(-5, 5), "begin < -srcLength, end > srcLength");
+});
+
+
+// class C {
+//   // static #method = () => 1;
+//   static #method() {
+//     return 'Test262';
+//   }
+
+//   static getPrivateMethod() {
+//     this.#method = () => 2;
+//     return this.#method();
+//   }
+// }
+
+// console.log(C.getPrivateMethod())
 
 // var __assert_throws = (expectedErrorConstructor, func) => {
 //   if (typeof func !== 'function') {

package/runner/index.js

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