porffor 0.58.14 → 0.58.16

package/compiler/builtins/array.ts

@@ -80,6 +80,29 @@ export const __Array_from = (arg: any, mapFn: any): any[] => {
   return out;
 };
 
+// 23.1.3.1 Array.prototype.at (index)
+// https://tc39.es/ecma262/multipage/indexed-collections.html#sec-array.prototype.at
+export const __Array_prototype_at = (_this: any[], index: any) => {
+  // 1. Let O be ? ToObject(this value).
+  // 2. Let len be ? LengthOfArrayLike(O).
+  const len: i32 = _this.length;
+
+  // 3. Let relativeIndex be ? ToIntegerOrInfinity(index).
+  index = ecma262.ToIntegerOrInfinity(index);
+
+  // 4. If relativeIndex ≥ 0, then
+  //        a. Let k be relativeIndex.
+  // 5. Else,
+  //        a. Let k be len + relativeIndex.
+  if (index < 0) index = len + index;
+
+  // 6. If k < 0 or k ≥ len, return undefined.
+  if (Porffor.fastOr(index < 0, index >= len)) return undefined;
+
+  // 7. Return ? Get(O, ! ToString(𝔽(k))).
+  return _this[index];
+};
+
 export const __Array_prototype_push = (_this: any[], ...items: any[]) => {
   let len: i32 = _this.length;
   const itemsLen: i32 = items.length;

package/compiler/builtins/regexp.ts

@@ -164,6 +164,25 @@ export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytest
         else if (char == 118) v = 11; // \v
         else if (char == 102) v = 12; // \f
         else if (char == 48) v = 0; // \0
+        else if (char == 120) { // \x
+          if (patternPtr + 1 >= patternEndPtr) throw new SyntaxError('Regex parse: invalid \\x escape');
+          const c1 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+          const c2 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+
+          let d1: number;
+          if (c1 >= 48 && c1 <= 57) d1 = c1 - 48;
+            else if (c1 >= 97 && c1 <= 102) d1 = c1 - 87;
+            else if (c1 >= 65 && c1 <= 70) d1 = c1 - 55;
+            else throw new SyntaxError('Regex parse: invalid \\x escape');
+
+          let d2: number;
+          if (c2 >= 48 && c2 <= 57) d2 = c2 - 48;
+            else if (c2 >= 97 && c2 <= 102) d2 = c2 - 87;
+            else if (c2 >= 65 && c2 <= 70) d2 = c2 - 55;
+            else throw new SyntaxError('Regex parse: invalid \\x escape');
+
+          v = d1 * 16 + d2;
+        }
       }
 
       if ((patternPtr + 1) < patternEndPtr && Porffor.wasm.i32.load8_u(patternPtr, 0, 4) == 45 && Porffor.wasm.i32.load8_u(patternPtr, 0, 5) != 93) {
@@ -194,6 +213,25 @@ export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytest
             else if (endChar == 118) endChar = 11;
             else if (endChar == 102) endChar = 12;
             else if (endChar == 48) endChar = 0;
+            else if (endChar == 120) { // \x
+              if (patternPtr + 1 >= patternEndPtr) throw new SyntaxError('Regex parse: invalid \\x escape');
+              const c1 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+              const c2 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+
+              let d1: number;
+              if (c1 >= 48 && c1 <= 57) d1 = c1 - 48;
+                else if (c1 >= 97 && c1 <= 102) d1 = c1 - 87;
+                else if (c1 >= 65 && c1 <= 70) d1 = c1 - 55;
+                else throw new SyntaxError('Regex parse: invalid \\x escape');
+
+              let d2: number;
+              if (c2 >= 48 && c2 <= 57) d2 = c2 - 48;
+                else if (c2 >= 97 && c2 <= 102) d2 = c2 - 87;
+                else if (c2 >= 65 && c2 <= 70) d2 = c2 - 55;
+                else throw new SyntaxError('Regex parse: invalid \\x escape');
+
+              endChar = d1 * 16 + d2;
+            }
         }
 
         // If either side is a predefined class, treat as literal chars
@@ -674,6 +712,30 @@ export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytest
         lastWasAtom = true;
         continue;
       }
+      if (char == 120) { // \x
+        if (patternPtr + 1 >= patternEndPtr) throw new SyntaxError('Regex parse: invalid \\x escape');
+        const c1 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+        const c2 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+
+        let d1: number;
+        if (c1 >= 48 && c1 <= 57) d1 = c1 - 48;
+          else if (c1 >= 97 && c1 <= 102) d1 = c1 - 87;
+          else if (c1 >= 65 && c1 <= 70) d1 = c1 - 55;
+          else throw new SyntaxError('Regex parse: invalid \\x escape');
+
+        let d2: number;
+        if (c2 >= 48 && c2 <= 57) d2 = c2 - 48;
+          else if (c2 >= 97 && c2 <= 102) d2 = c2 - 87;
+          else if (c2 >= 65 && c2 <= 70) d2 = c2 - 55;
+          else throw new SyntaxError('Regex parse: invalid \\x escape');
+
+        lastAtomStart = bcPtr;
+        Porffor.wasm.i32.store8(bcPtr, 0x01, 0, 0);
+        Porffor.wasm.i32.store8(bcPtr, d1 * 16 + d2, 0, 1);
+        bcPtr += 2;
+        lastWasAtom = true;
+        continue;
+      }
     }
 
     // default: emit single char (either a literal, or an escape that resolves to a literal)