@zigc/lib 0.17.0-dev.44 → 0.17.0-dev.607

package/compiler_rt/exp.zig

@@ -198,8 +198,6 @@ const expq = @import("exp_f128.zig").exp;
 
 pub fn expl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __exph(x),
-        32 => return expf(x),
         64 => return exp(x),
         80 => return __expx(x),
         128 => return expq(x),

package/compiler_rt/exp2.zig

@@ -165,8 +165,6 @@ pub const exp2q = @import("exp_f128.zig").exp2;
 
 pub fn exp2l(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __exp2h(x),
-        32 => return exp2f(x),
         64 => return exp2(x),
         80 => return __exp2x(x),
         128 => return exp2q(x),

package/compiler_rt/extendf.zig

@@ -3,10 +3,10 @@ const std = @import("std");
 pub inline fn extendf(
     comptime dst_t: type,
     comptime src_t: type,
-    a: std.meta.Int(.unsigned, @typeInfo(src_t).float.bits),
+    a: @Int(.unsigned, @typeInfo(src_t).float.bits),
 ) dst_t {
-    const src_rep_t = std.meta.Int(.unsigned, @typeInfo(src_t).float.bits);
-    const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).float.bits);
+    const src_rep_t = @Int(.unsigned, @typeInfo(src_t).float.bits);
+    const dst_rep_t = @Int(.unsigned, @typeInfo(dst_t).float.bits);
     const srcSigBits = std.math.floatMantissaBits(src_t);
     const dstSigBits = std.math.floatMantissaBits(dst_t);
 
@@ -70,8 +70,8 @@ pub inline fn extendf(
     return @bitCast(result);
 }
 
-pub inline fn extend_f80(comptime src_t: type, a: std.meta.Int(.unsigned, @typeInfo(src_t).float.bits)) f80 {
-    const src_rep_t = std.meta.Int(.unsigned, @typeInfo(src_t).float.bits);
+pub inline fn extend_f80(comptime src_t: type, a: @Int(.unsigned, @typeInfo(src_t).float.bits)) f80 {
+    const src_rep_t = @Int(.unsigned, @typeInfo(src_t).float.bits);
     const src_sig_bits = std.math.floatMantissaBits(src_t);
     const dst_int_bit = 0x8000000000000000;
     const dst_sig_bits = std.math.floatMantissaBits(f80) - 1; // -1 for the integer bit

package/compiler_rt/fabs.zig

@@ -38,8 +38,6 @@ pub fn fabsq(a: f128) callconv(.c) f128 {
 
 pub fn fabsl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __fabsh(x),
-        32 => return fabsf(x),
         64 => return fabs(x),
         80 => return __fabsx(x),
         128 => return fabsq(x),
@@ -49,7 +47,7 @@ pub fn fabsl(x: c_longdouble) callconv(.c) c_longdouble {
 
 inline fn generic_fabs(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
-    const TBits = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+    const TBits = @Int(.unsigned, @typeInfo(T).float.bits);
     const float_bits: TBits = @bitCast(x);
     const remove_sign = ~@as(TBits, 0) >> 1;
     return @bitCast(float_bits & remove_sign);

package/compiler_rt/float_from_int.zig

@@ -1,5 +1,4 @@
 const std = @import("std");
-const Int = std.meta.Int;
 const math = std.math;
 
 pub fn floatFromInt(comptime T: type, x: anytype) T {
@@ -7,14 +6,14 @@ pub fn floatFromInt(comptime T: type, x: anytype) T {
 
     // Various constants whose values follow from the type parameters.
     // Any reasonable optimizer will fold and propagate all of these.
-    const Z = Int(.unsigned, @bitSizeOf(@TypeOf(x)));
-    const uT = Int(.unsigned, @bitSizeOf(T));
+    const Z = @Int(.unsigned, @bitSizeOf(@TypeOf(x)));
+    const uT = @Int(.unsigned, @bitSizeOf(T));
     const inf = math.inf(T);
     const float_bits = @bitSizeOf(T);
     const int_bits = @bitSizeOf(@TypeOf(x));
     const exp_bits = math.floatExponentBits(T);
     const fractional_bits = math.floatFractionalBits(T);
-    const exp_bias = math.maxInt(Int(.unsigned, exp_bits - 1));
+    const exp_bias = math.maxInt(@Int(.unsigned, exp_bits - 1));
     const implicit_bit = if (T != f80) @as(uT, 1) << fractional_bits else 0;
     const max_exp = exp_bias;
 
@@ -98,7 +97,7 @@ pub inline fn floatFromBigInt(comptime T: type, comptime signedness: std.builtin
         if (limb(x, limb_index) != 0) break true;
     } else limb(x, exponent_limb) & ((@as(u32, 1) << @truncate(exponent)) - 1) != 0;
     return math.ldexp(@as(T, @floatFromInt(
-        std.mem.readPackedIntNative(I, std.mem.sliceAsBytes(x), exponent) | @intFromBool(sticky),
+        std.mem.readPackedInt(I, std.mem.sliceAsBytes(x), exponent, .native) | @intFromBool(sticky),
     )), @intCast(exponent));
 }
 

package/compiler_rt/fma.zig

@@ -151,8 +151,6 @@ pub fn fmaq(x: f128, y: f128, z: f128) callconv(.c) f128 {
 
 pub fn fmal(x: c_longdouble, y: c_longdouble, z: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __fmah(x, y, z),
-        32 => return fmaf(x, y, z),
         64 => return fma(x, y, z),
         80 => return __fmax(x, y, z),
         128 => return fmaq(x, y, z),

package/compiler_rt/fmax.zig

@@ -39,8 +39,6 @@ pub fn fmaxq(x: f128, y: f128) callconv(.c) f128 {
 
 pub fn fmaxl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __fmaxh(x, y),
-        32 => return fmaxf(x, y),
         64 => return fmax(x, y),
         80 => return __fmaxx(x, y),
         128 => return fmaxq(x, y),
@@ -61,7 +59,7 @@ inline fn generic_fmax(comptime T: type, x: T, y: T) T {
 test "generic_fmax" {
     inline for ([_]type{ f32, f64, c_longdouble, f80, f128 }) |T| {
         const nan_val = math.nan(T);
-        const Int = std.meta.Int(.unsigned, @bitSizeOf(T));
+        const Int = @Int(.unsigned, @bitSizeOf(T));
 
         try std.testing.expect(math.isNan(generic_fmax(T, nan_val, nan_val)));
         try std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, nan_val, 1.0));

package/compiler_rt/fmin.zig

@@ -39,8 +39,6 @@ pub fn fminq(x: f128, y: f128) callconv(.c) f128 {
 
 pub fn fminl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __fminh(x, y),
-        32 => return fminf(x, y),
         64 => return fmin(x, y),
         80 => return __fminx(x, y),
         128 => return fminq(x, y),
@@ -61,7 +59,7 @@ inline fn generic_fmin(comptime T: type, x: T, y: T) T {
 test "generic_fmin" {
     inline for ([_]type{ f32, f64, c_longdouble, f80, f128 }) |T| {
         const nan_val = math.nan(T);
-        const Int = std.meta.Int(.unsigned, @bitSizeOf(T));
+        const Int = @Int(.unsigned, @bitSizeOf(T));
 
         try std.testing.expect(math.isNan(generic_fmin(T, nan_val, nan_val)));
         try std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, nan_val, 1.0));

package/compiler_rt/fmod.zig

@@ -36,7 +36,7 @@ pub fn fmod(x: f64, y: f64) callconv(.c) f64 {
 /// Logic and flow heavily inspired by MUSL fmodl for 113 mantissa digits
 pub fn __fmodx(a: f80, b: f80) callconv(.c) f80 {
     const T = f80;
-    const Z = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const Z = @Int(.unsigned, @bitSizeOf(T));
 
     const significandBits = math.floatMantissaBits(T);
     const fractionalBits = math.floatFractionalBits(T);
@@ -251,8 +251,6 @@ pub fn fmodq(a: f128, b: f128) callconv(.c) f128 {
 
 pub fn fmodl(a: c_longdouble, b: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __fmodh(a, b),
-        32 => return fmodf(a, b),
         64 => return fmod(a, b),
         80 => return __fmodx(a, b),
         128 => return fmodq(a, b),
@@ -262,7 +260,7 @@ pub fn fmodl(a: c_longdouble, b: c_longdouble) callconv(.c) c_longdouble {
 
 inline fn generic_fmod(comptime T: type, x: T, y: T) T {
     const bits = @typeInfo(T).float.bits;
-    const uint = std.meta.Int(.unsigned, bits);
+    const uint = @Int(.unsigned, bits);
     comptime assert(T == f32 or T == f64);
     const digits = if (T == f32) 23 else 52;
     const exp_bits = if (T == f32) 9 else 12;

package/compiler_rt/int_from_float.zig

@@ -141,7 +141,7 @@ pub inline fn bigIntFromFloat(comptime signedness: std.builtin.Signedness, resul
         },
         .unsigned => @memset(result, 0),
     }
-    std.mem.writePackedIntNative(I, std.mem.sliceAsBytes(result), exponent, int);
+    std.mem.writePackedInt(I, std.mem.sliceAsBytes(result), exponent, int, .native);
 }
 
 test {

package/compiler_rt/limb64.zig

@@ -57,9 +57,10 @@ fn fixLastLimb(out_ptr: [*]u64, is_signed: bool, bits: u16) void {
     if (limb_cnt == true_limb_cnt) return;
     const true_out = out_ptr[0..true_limb_cnt];
 
-    const sign: u64 = if (!is_signed or @as(i64, @bitCast(true_out[limb_cnt - 1])) >= 0) 0 else ~@as(u64, 0);
+    const ms = limbGet(true_out, limb_cnt - 1);
+    const sign: u64 = if (!is_signed or @as(i64, @bitCast(ms)) >= 0) 0 else ~@as(u64, 0);
     for (limb_cnt..true_limb_cnt) |i| {
-        true_out[i] = sign;
+        limbSet(true_out, i, sign);
     }
 }
 

package/compiler_rt/log.zig

@@ -443,8 +443,6 @@ pub fn logq(a: f128) callconv(.c) f128 {
 
 pub fn logl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __logh(x),
-        32 => return logf(x),
         64 => return log(x),
         80 => return __logx(x),
         128 => return logq(x),

package/compiler_rt/log10.zig

@@ -177,8 +177,6 @@ pub fn log10q(a: f128) callconv(.c) f128 {
 
 pub fn log10l(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __log10h(x),
-        32 => return log10f(x),
         64 => return log10(x),
         80 => return __log10x(x),
         128 => return log10q(x),

package/compiler_rt/log2.zig

@@ -170,8 +170,6 @@ pub fn log2q(a: f128) callconv(.c) f128 {
 
 pub fn log2l(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __log2h(x),
-        32 => return log2f(x),
         64 => return log2(x),
         80 => return __log2x(x),
         128 => return log2q(x),

package/compiler_rt/mulf3.zig

@@ -12,7 +12,7 @@ pub inline fn mulf3(comptime T: type, a: T, b: T) T {
     const fractionalBits = math.floatFractionalBits(T);
     const exponentBits = math.floatExponentBits(T);
 
-    const Z = std.meta.Int(.unsigned, typeWidth);
+    const Z = @Int(.unsigned, typeWidth);
 
     // ZSignificand is large enough to contain the significand, including an explicit integer bit
     const ZSignificand = PowerOfTwoSignificandZ(T);
@@ -195,7 +195,7 @@ fn normalize(comptime T: type, significand: *PowerOfTwoSignificandZ(T)) i32 {
 /// the significand of T, including an explicit integer bit
 fn PowerOfTwoSignificandZ(comptime T: type) type {
     const bits = math.ceilPowerOfTwoAssert(u16, math.floatFractionalBits(T) + 1);
-    return std.meta.Int(.unsigned, bits);
+    return @Int(.unsigned, bits);
 }
 
 test {

package/compiler_rt/rem_pio2l.zig

@@ -5,8 +5,8 @@
 
 const std = @import("std");
 const math = std.math;
+const ld = math.long_double;
 
-const ld = @import("long_double.zig");
 const rem_pio2_large = @import("rem_pio2_large.zig").rem_pio2_large;
 
 pub fn rem_pio2l(comptime T: type, x: T, y: *[2]T) i32 {

package/compiler_rt/round.zig

@@ -142,8 +142,6 @@ pub fn roundq(x_: f128) callconv(.c) f128 {
 
 pub fn roundl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __roundh(x),
-        32 => return roundf(x),
         64 => return round(x),
         80 => return __roundx(x),
         128 => return roundq(x),

package/compiler_rt/sin.zig

@@ -7,6 +7,7 @@
 
 const std = @import("std");
 const math = std.math;
+const ld = math.long_double;
 const mem = std.mem;
 const expect = std.testing.expect;
 const expectApproxEqAbs = std.testing.expectApproxEqAbs;
@@ -17,7 +18,6 @@ const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 const rem_pio2l = @import("rem_pio2l.zig").rem_pio2l;
-const ld = @import("long_double.zig");
 
 comptime {
     symbol(&sinh, "__sinh");
@@ -189,8 +189,6 @@ pub fn sinq(x: f128) callconv(.c) f128 {
 
 pub fn sinl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return sinh(x),
-        32 => return sinf(x),
         64 => return sin(x),
         80 => return sinx(x),
         128 => return sinq(x),

package/compiler_rt/sincos.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
 const math = std.math;
+const ld = math.long_double;
 const mem = std.mem;
 const expect = std.testing.expect;
 const expectApproxEqAbs = std.testing.expectApproxEqAbs;
@@ -9,7 +10,6 @@ const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 const rem_pio2l = @import("rem_pio2l.zig").rem_pio2l;
-const ld = @import("long_double.zig");
 const compiler_rt = @import("../compiler_rt.zig");
 const symbol = compiler_rt.symbol;
 
@@ -292,8 +292,6 @@ pub fn sincosq(x: f128, r_sin: *f128, r_cos: *f128) callconv(.c) void {
 
 pub fn sincosl(x: c_longdouble, r_sin: *c_longdouble, r_cos: *c_longdouble) callconv(.c) void {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return sincosh(x, r_sin, r_cos),
-        32 => return sincosf(x, r_sin, r_cos),
         64 => return sincos(x, r_sin, r_cos),
         80 => return sincosx(x, r_sin, r_cos),
         128 => return sincosq(x, r_sin, r_cos),

package/compiler_rt/sqrt.zig

@@ -481,8 +481,6 @@ fn _Qp_sqrt(c: *f128, a: *f128) callconv(.c) void {
 
 pub fn sqrtl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __sqrth(x),
-        32 => return sqrtf(x),
         64 => return sqrt(x),
         80 => return __sqrtx(x),
         128 => return sqrtq(x),

package/compiler_rt/ssp.zig

@@ -44,10 +44,10 @@ fn __chk_fail() callconv(.c) noreturn {
 
 // TODO: Initialize the canary with random data
 var __stack_chk_guard: usize = blk: {
-    var buf = [1]u8{0} ** @sizeOf(usize);
+    var buf: [@sizeOf(usize)]u8 = @splat(0);
     buf[@sizeOf(usize) - 1] = 255;
     buf[@sizeOf(usize) - 2] = '\n';
-    break :blk @as(usize, @bitCast(buf));
+    break :blk @bitCast(buf);
 };
 
 fn __strcpy_chk(dest: [*:0]u8, src: [*:0]const u8, dest_n: usize) callconv(.c) [*:0]u8 {

package/compiler_rt/tan.zig

@@ -9,6 +9,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const math = std.math;
+const ld = math.long_double;
 const mem = std.mem;
 const expect = std.testing.expect;
 const expectApproxEqAbs = std.testing.expectApproxEqAbs;
@@ -17,7 +18,6 @@ const kernel = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 const rem_pio2l = @import("rem_pio2l.zig").rem_pio2l;
-const ld = @import("long_double.zig");
 
 const arch = builtin.cpu.arch;
 const compiler_rt = @import("../compiler_rt.zig");
@@ -164,8 +164,6 @@ pub fn tanq(x: f128) callconv(.c) f128 {
 
 pub fn tanl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return tanh(x),
-        32 => return tanf(x),
         64 => return tan(x),
         80 => return tanx(x),
         128 => return tanq(x),

package/compiler_rt/trunc.zig

@@ -99,8 +99,6 @@ pub fn truncq(x: f128) callconv(.c) f128 {
 
 pub fn truncl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __trunch(x),
-        32 => return truncf(x),
         64 => return trunc(x),
         80 => return __truncx(x),
         128 => return truncq(x),

package/compiler_rt/truncf.zig

@@ -1,8 +1,8 @@
 const std = @import("std");
 
 pub inline fn truncf(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t {
-    const src_rep_t = std.meta.Int(.unsigned, @typeInfo(src_t).float.bits);
-    const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).float.bits);
+    const src_rep_t = @Int(.unsigned, @typeInfo(src_t).float.bits);
+    const dst_rep_t = @Int(.unsigned, @typeInfo(dst_t).float.bits);
     const srcSigBits = std.math.floatMantissaBits(src_t);
     const dstSigBits = std.math.floatMantissaBits(dst_t);
 
@@ -100,7 +100,7 @@ pub inline fn truncf(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t
 }
 
 pub inline fn trunc_f80(comptime dst_t: type, a: f80) dst_t {
-    const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).float.bits);
+    const dst_rep_t = @Int(.unsigned, @typeInfo(dst_t).float.bits);
     const src_sig_bits = std.math.floatMantissaBits(f80) - 1; // -1 for the integer bit
     const dst_sig_bits = std.math.floatMantissaBits(dst_t);
 

package/compiler_rt/trunctfhf2.zig

@@ -4,6 +4,9 @@ const truncf = @import("./truncf.zig").truncf;
 
 comptime {
     symbol(&__trunctfhf2, "__trunctfhf2");
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__trunctfhf2, "__trunckfhf2");
+    }
 }
 
 pub fn __trunctfhf2(a: f128) callconv(.c) compiler_rt.F16T(f128) {

package/compiler_rt.zig

@@ -447,29 +447,8 @@ pub const gnu_f16_abi = switch (builtin.cpu.arch) {
 
 pub const want_sparc_abi = builtin.cpu.arch.isSPARC();
 
-/// This seems to mostly correspond to `clang::TargetInfo::HasFloat16`.
 pub fn F16T(comptime OtherType: type) type {
     return switch (builtin.cpu.arch) {
-        .amdgcn,
-        .arm,
-        .armeb,
-        .thumb,
-        .thumbeb,
-        .aarch64,
-        .aarch64_be,
-        .hexagon,
-        .loongarch32,
-        .loongarch64,
-        .nvptx,
-        .nvptx64,
-        .riscv32,
-        .riscv32be,
-        .riscv64,
-        .riscv64be,
-        .s390x,
-        .spirv32,
-        .spirv64,
-        => f16,
         .x86, .x86_64 => if (builtin.target.os.tag.isDarwin()) switch (OtherType) {
             // Starting with LLVM 16, Darwin uses different abi for f16
             // depending on the type of the other return/argument..???
@@ -477,7 +456,7 @@ pub fn F16T(comptime OtherType: type) type {
             f80, f128 => f16,
             else => unreachable,
         } else f16,
-        else => u16,
+        else => f16,
     };
 }
 
@@ -595,8 +574,8 @@ pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
     }
 }
 
-pub fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeInfo(T).float.bits)) i32 {
-    const Z = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+pub fn normalize(comptime T: type, significand: *@Int(.unsigned, @typeInfo(T).float.bits)) i32 {
+    const Z = @Int(.unsigned, @typeInfo(T).float.bits);
     const integerBit = @as(Z, 1) << std.math.floatFractionalBits(T);
 
     const shift = @clz(significand.*) - @clz(integerBit);
@@ -646,8 +625,8 @@ fn __aeabi_fneg(a: f32) callconv(.{ .arm_aapcs = .{} }) f32 {
 pub fn HalveInt(comptime T: type, comptime signed_half: bool) type {
     return extern union {
         pub const bits = @divExact(@typeInfo(T).int.bits, 2);
-        pub const HalfTU = std.meta.Int(.unsigned, bits);
-        pub const HalfTS = std.meta.Int(.signed, bits);
+        pub const HalfTU = @Int(.unsigned, bits);
+        pub const HalfTS = @Int(.signed, bits);
         pub const HalfT = if (signed_half) HalfTS else HalfTU;
 
         all: T,

package/docs/main.js

@@ -697,7 +697,7 @@
     }
 
     function onSearchKeyDown(ev) {
-      switch (ev.code) {
+      switch (ev.key) {
         case "Enter":
           if (ev.shiftKey || ev.ctrlKey || ev.altKey) return;
 
@@ -763,7 +763,7 @@
     }
 
     function onWindowKeyDown(ev) {
-        switch (ev.code) {
+        switch (ev.key) {
             case "Escape":
                 if (ev.shiftKey || ev.ctrlKey || ev.altKey) return;
                 if (!domHelpModal.classList.contains("hidden")) {
@@ -772,22 +772,22 @@
                     ev.stopPropagation();
                 }
                 break;
-            case "KeyS":
-                if (ev.shiftKey || ev.ctrlKey || ev.altKey) return;
+            case "s":
+                if (ev.ctrlKey || ev.altKey) return;
                 domSearch.focus();
                 domSearch.select();
                 ev.preventDefault();
                 ev.stopPropagation();
                 startAsyncSearch();
                 break;
-            case "KeyU":
-                if (ev.shiftKey || ev.ctrlKey || ev.altKey) return;
+            case "u":
+                if (ev.ctrlKey || ev.altKey) return;
                 ev.preventDefault();
                 ev.stopPropagation();
                 navigateToSource();
                 break;
-            case "Slash":
-                if (!ev.shiftKey || ev.ctrlKey || ev.altKey) return;
+            case "?":
+                if (ev.ctrlKey || ev.altKey) return;
                 ev.preventDefault();
                 ev.stopPropagation();
                 showHelpModal();

package/docs/wasm/Walk.zig

@@ -709,7 +709,6 @@ fn expr(w: *Walk, scope: *Scope, parent_decl: Decl.Index, node: Ast.Node.Index)
         .less_or_equal,
         .array_cat,
 
-        .array_mult,
         .error_union,
         .merge_error_sets,
         .bool_and,
@@ -1014,8 +1013,7 @@ fn block(
 
             .grouped_expression => try expr(w, scope, parent_decl, ast.nodeData(node).node_and_token[0]),
 
-            .@"defer" => try expr(w, scope, parent_decl, ast.nodeData(node).node),
-            .@"errdefer" => try expr(w, scope, parent_decl, ast.nodeData(node).opt_token_and_node[1]),
+            .@"defer", .@"errdefer" => try expr(w, scope, parent_decl, ast.nodeData(node).node),
 
             else => try expr(w, scope, parent_decl, node),
         }

package/docs/wasm/html_render.zig

@@ -302,7 +302,6 @@ pub fn fileSourceHtml(
             .minus_pipe_equal,
             .asterisk,
             .asterisk_equal,
-            .asterisk_asterisk,
             .asterisk_percent,
             .asterisk_percent_equal,
             .asterisk_pipe,
@@ -328,7 +327,7 @@ pub fn fileSourceHtml(
             .tilde,
             => try appendEscaped(out, slice),
 
-            .invalid, .invalid_periodasterisks => return error.InvalidToken,
+            .invalid => return error.InvalidToken,
         }
     }
 }