Ray-AABB (Axis Aligned Bounding Box) intersection.

intersectAABB.glsl

// adapted from intersectCube in https://github.com/evanw/webgl-path-tracing/blob/master/webgl-path-tracing.js

// compute the near and far intersections of the cube (stored in the x and y components) using the slab method
// no intersection means vec.x > vec.y (really tNear > tFar)
vec2 intersectAABB(vec3 rayOrigin, vec3 rayDir, vec3 boxMin, vec3 boxMax) {
    vec3 tMin = (boxMin - rayOrigin) / rayDir;
    vec3 tMax = (boxMax - rayOrigin) / rayDir;
    vec3 t1 = min(tMin, tMax);
    vec3 t2 = max(tMin, tMax);
    float tNear = max(max(t1.x, t1.y), t1.z);
    float tFar = min(min(t2.x, t2.y), t2.z);
    return vec2(tNear, tFar);
};

That type name is absurdly long.

Here's a simplified/optimised version in TypeScript that I'm pretty sure is equivalent to OP. Math.min() and Math.max() operators handle Infinity and -Infinity correctly so it works for axis-aligned rays.

export function rayAABBIntersection(rayOrigin: Vector3, rayDir: Vector3, aabb: AxisAlignedBoundingBox): number | undefined {
  const tMin = new Vector3(
    (aabb.xMin - rayOrigin.x) / rayDir.x,
    (aabb.yMin - rayOrigin.y) / rayDir.y,
    (aabb.zMin - rayOrigin.z) / rayDir.z,
  );
  const tMax = new Vector3(
    (aabb.xMax - rayOrigin.x) / rayDir.x,
    (aabb.yMax - rayOrigin.y) / rayDir.y,
    (aabb.zMax - rayOrigin.z) / rayDir.z,
  );

  const tNear = Math.max(
    Math.min(tMin.x, tMax.x),
    Math.min(tMin.y, tMax.y),
    Math.min(tMin.z, tMax.z),
  );
  const tFar = Math.min(
    Math.max(tMin.x, tMax.x),
    Math.max(tMin.y, tMax.y),
    Math.max(tMin.z, tMax.z),
  );

  if (tNear <= tFar) {
    // Ray intersects AABB
    return tNear;
  } else {
    // Ray does not intersect AABB
    return undefined;
  }
};

You can calculate the intersection point as rayOrigin + tNear * rayDir if you need that.