@scriptc/compiler 0.0.17 → 0.0.18

package/dist/frontend/lowering/lower-containers.d.ts

@@ -93,20 +93,23 @@ export declare function lowerArrayFlatMapCall(L: Lowerer, call: ts.CallExpressio
    * any prefix of (acc, element, index, array). Without an initial value an
    * empty receiver throws Node's exact TypeError at runtime. */
 export declare function lowerArrayReduceCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, method: "reduce" | "reduceRight", elem: IrType): IrExpr;
-/** `a.sort(cmp)` — in-place, returns the receiver (JS's `this`), desugared
-   * to an interned synthetic function like the other array HOFs. The loop
-   * is a binary-free INSERTION sort: stable (equal-comparing elements keep
-   * their source order, which is what Node's stable TimSort produces for
-   * any consistent comparator) and JS-faithful on the comparator contract —
-   * an element moves left only while cmp(left, v) > 0, so a NaN or 0
-   * result holds position exactly like the spec's "treat as equal". The
-   * SEQUENCE of comparator calls differs from V8's TimSort (SEMANTICS.md);
-   * results are identical for consistent comparators. The comparator-less
-   * form lowers for STRING elements only — JS's default converts every
-   * element to string and compares UTF-16 units, which for strings is the
-   * relational operator the compiler already has (an interned synthesized
-   * comparator); for numbers that default is the notorious string sort
-   * ([10, 9, 1] → [1, 10, 9]), deliberately fenced toward an explicit
+/** `a.sort(cmp)` / `a.toSorted(cmp)`, desugared to an interned synthetic
+   * function like the other array HOFs. sort mutates and returns the receiver;
+   * toSorted takes its shallow snapshot INSIDE the helper, after the receiver
+   * and comparator expressions have both been evaluated, then sorts and
+   * returns that copy without touching the receiver. The loop is a
+   * binary-free INSERTION sort: stable (equal-comparing elements keep their
+   * source order, which is what Node's stable TimSort produces for any
+   * consistent comparator) and JS-faithful on the comparator contract — an
+   * element moves left only while cmp(left, v) > 0, so a NaN or 0 result holds
+   * position exactly like the spec's "treat as equal". The SEQUENCE of
+   * comparator calls differs from V8's TimSort (SEMANTICS.md); results are
+   * identical for consistent comparators. The comparator-less form lowers for
+   * STRING elements only — JS's default converts every element to string and
+   * compares UTF-16 units, so the interned synthesized comparator selects the
+   * runtime's code-unit ordering rather than scriptc's documented code-point
+   * relational operators. For numbers that default is the notorious string
+   * sort ([10, 9, 1] → [1, 10, 9]), deliberately fenced toward an explicit
    * comparator. */
 export declare function lowerArraySortCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, elem: IrType, arrT: IrType & {
     kind: "array";
@@ -274,7 +277,7 @@ export type ForOfIterProjection = "keys" | "values" | "entries";
    * enter/exit bracketing: the pair list compacts immediately (no
    * tombstones), so there is no iteration depth to keep exact. */
 export declare function lowerForOfSearchParams(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, proj?: ForOfIterProjection): IrStmt;
-/** for-of over an ARRAY's keys()/entries() projections consumed directly
+/** for-of over an ARRAY/typed-array keys()/entries() projection consumed directly
    * by the head (`for (const [index, line] of lines.entries())` — the
    * dominant formatter idiom): the LIVE index walk — the length re-reads
    * every pass, exactly the array iterator's contract (elements appended
@@ -287,9 +290,11 @@ export declare function lowerForOfSearchParams(L: Lowerer, stmt: ts.ForOfStateme
    * [number, T] tuple record. Stored iterator OBJECTS keep their fence
    * (only the direct for-of position unwraps). */
 export declare function lowerForOfArrayIter(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr & {
-    type: IrType & {
+    type: (IrType & {
         kind: "array";
-    };
+    }) | (IrType & {
+        kind: "bytes";
+    });
 }, proj: "keys" | "entries"): IrStmt;
 export declare function lowerForOfMap(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, mapT: IrType & {
     kind: "map";