@nulib/clover 0.0.0-stage → 4.0.0-beta.0

package/dist/lib/gltf/renderer.mjs

@@ -0,0 +1,342 @@
+"use client";
+import { emptyBox, growBox } from "./bounds.mjs";
+import { componentsOf } from "./load.mjs";
+import { multiply, compose, normalMatrix } from "./mat4.mjs";
+import { TEXTURES, ATTRIBUTES, VERTEX, FRAGMENT, FLAGS } from "./shaders.mjs";
+const REPEAT = 10497;
+const LINEAR = 9729;
+const MIPMAPS = /* @__PURE__ */ new Set([9984, 9985, 9986, 9987]);
+function compile(gl) {
+  const program = gl.createProgram();
+  for (const [type, source] of [
+    [gl.VERTEX_SHADER, VERTEX],
+    [gl.FRAGMENT_SHADER, FRAGMENT]
+  ]) {
+    const shader = gl.createShader(type);
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+    gl.attachShader(program, shader);
+    gl.deleteShader(shader);
+  }
+  gl.linkProgram(program);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS))
+    throw new Error(
+      `The 3D view's shaders would not build: ${gl.getProgramInfoLog(program)}`
+    );
+  return program;
+}
+function createModelRenderer(gl) {
+  const program = compile(gl);
+  const uniform = (name) => gl.getUniformLocation(program, name);
+  const u = Object.fromEntries(
+    [
+      "uModel",
+      "uViewProjection",
+      "uNormalMatrix",
+      "uCamera",
+      "uBaseColor",
+      "uSpecular",
+      "uMetallic",
+      "uRoughness",
+      "uNormalScale",
+      "uOcclusionStrength",
+      "uEmissive",
+      "uAlphaCutoff",
+      "uFlags",
+      ...TEXTURES
+    ].map((name) => [name, uniform(name)])
+  );
+  gl.useProgram(program);
+  TEXTURES.forEach((name, unit) => gl.uniform1i(u[name], unit));
+  const buffers = [];
+  const textures = [];
+  const draws = [];
+  const box = emptyBox();
+  const white = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, white);
+  gl.texImage2D(
+    gl.TEXTURE_2D,
+    0,
+    gl.RGBA8,
+    1,
+    1,
+    0,
+    gl.RGBA,
+    gl.UNSIGNED_BYTE,
+    new Uint8Array([255, 255, 255, 255])
+  );
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+  textures.push(white);
+  gl.vertexAttrib4f(ATTRIBUTES.COLOR_0, 1, 1, 1, 1);
+  function add(asset, placement) {
+    var _a;
+    const { json } = asset;
+    const views = /* @__PURE__ */ new Map();
+    const images = /* @__PURE__ */ new Map();
+    const materials = /* @__PURE__ */ new Map();
+    const viewBuffer = (index, target) => {
+      const key = `${index}|${target}`;
+      let buffer = views.get(key);
+      if (!buffer) {
+        const view = json.bufferViews[index];
+        buffer = gl.createBuffer();
+        gl.bindBuffer(target, buffer);
+        gl.bufferData(
+          target,
+          new Uint8Array(
+            asset.buffers[view.buffer],
+            view.byteOffset ?? 0,
+            view.byteLength
+          ),
+          gl.STATIC_DRAW
+        );
+        views.set(key, buffer);
+        buffers.push(buffer);
+      }
+      return buffer;
+    };
+    const texture = (info, srgb) => {
+      var _a2, _b;
+      const definition = info ? (_a2 = json.textures) == null ? void 0 : _a2[info.index] : void 0;
+      const image = (definition == null ? void 0 : definition.source) !== void 0 ? asset.images[definition.source] : null;
+      if (!info || !image) return null;
+      const key = `${info.index}|${srgb}`;
+      let made = images.get(key);
+      if (!made) {
+        made = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, made);
+        gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
+        gl.texImage2D(
+          gl.TEXTURE_2D,
+          0,
+          srgb ? gl.SRGB8_ALPHA8 : gl.RGBA8,
+          gl.RGBA,
+          gl.UNSIGNED_BYTE,
+          image
+        );
+        const sampler = (definition == null ? void 0 : definition.sampler) !== void 0 ? (_b = json.samplers) == null ? void 0 : _b[definition.sampler] : void 0;
+        const min = (sampler == null ? void 0 : sampler.minFilter) ?? gl.LINEAR_MIPMAP_LINEAR;
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, min);
+        gl.texParameteri(
+          gl.TEXTURE_2D,
+          gl.TEXTURE_MAG_FILTER,
+          (sampler == null ? void 0 : sampler.magFilter) ?? LINEAR
+        );
+        gl.texParameteri(
+          gl.TEXTURE_2D,
+          gl.TEXTURE_WRAP_S,
+          (sampler == null ? void 0 : sampler.wrapS) ?? REPEAT
+        );
+        gl.texParameteri(
+          gl.TEXTURE_2D,
+          gl.TEXTURE_WRAP_T,
+          (sampler == null ? void 0 : sampler.wrapT) ?? REPEAT
+        );
+        if (MIPMAPS.has(min)) gl.generateMipmap(gl.TEXTURE_2D);
+        images.set(key, made);
+        textures.push(made);
+      }
+      return made;
+    };
+    const material = (index) => {
+      var _a2, _b, _c, _d, _e, _f;
+      const key = index ?? -1;
+      let made = materials.get(key);
+      if (made) return made;
+      const definition = index !== void 0 ? ((_a2 = json.materials) == null ? void 0 : _a2[index]) ?? {} : {};
+      const pbr = definition.pbrMetallicRoughness ?? {};
+      const normalMap = texture(definition.normalTexture, false);
+      const ior = Number(
+        ((_c = (_b = definition.extensions) == null ? void 0 : _b.KHR_materials_ior) == null ? void 0 : _c.ior) ?? 1.5
+      );
+      const specular = (_d = definition.extensions) == null ? void 0 : _d.KHR_materials_specular;
+      const reflectance = ((ior - 1) / (ior + 1)) ** 2;
+      made = {
+        base: pbr.baseColorFactor ?? [1, 1, 1, 1],
+        specular: ((specular == null ? void 0 : specular.specularColorFactor) ?? [1, 1, 1]).map(
+          (channel) => Math.min(reflectance * channel, 1) * ((specular == null ? void 0 : specular.specularFactor) ?? 1)
+        ),
+        metallic: pbr.metallicFactor ?? 1,
+        roughness: pbr.roughnessFactor ?? 1,
+        normalScale: ((_e = definition.normalTexture) == null ? void 0 : _e.scale) ?? 1,
+        occlusion: definition.occlusionTexture ? definition.occlusionTexture.strength ?? 1 : 0,
+        emissive: definition.emissiveFactor ?? [0, 0, 0],
+        cutoff: definition.alphaCutoff ?? 0.5,
+        flags: (normalMap ? FLAGS.normalMap : 0) | (((_f = definition.extensions) == null ? void 0 : _f.KHR_materials_unlit) ? FLAGS.unlit : 0) | (definition.alphaMode === "MASK" ? FLAGS.mask : 0),
+        doubleSided: Boolean(definition.doubleSided),
+        blend: definition.alphaMode === "BLEND",
+        textures: [
+          texture(pbr.baseColorTexture, true),
+          texture(pbr.metallicRoughnessTexture, false),
+          normalMap,
+          texture(definition.occlusionTexture, false),
+          texture(definition.emissiveTexture, true)
+        ]
+      };
+      materials.set(key, made);
+      return made;
+    };
+    const visit = (index, parent) => {
+      var _a2, _b, _c, _d;
+      const node = (_a2 = json.nodes) == null ? void 0 : _a2[index];
+      if (!node) return;
+      const world = multiply(
+        parent,
+        node.matrix ? new Float32Array(node.matrix) : compose(
+          node.translation ?? [0, 0, 0],
+          node.rotation ?? [0, 0, 0, 1],
+          node.scale ?? [1, 1, 1]
+        )
+      );
+      const mesh = node.mesh !== void 0 ? (_b = json.meshes) == null ? void 0 : _b[node.mesh] : void 0;
+      for (const primitive of (mesh == null ? void 0 : mesh.primitives) ?? []) {
+        const position = primitive.attributes.POSITION;
+        if (position === void 0) continue;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        let flags = 0;
+        for (const [name, location] of Object.entries(ATTRIBUTES)) {
+          const accessorIndex = primitive.attributes[name];
+          const accessor = accessorIndex !== void 0 ? (_c = json.accessors) == null ? void 0 : _c[accessorIndex] : void 0;
+          if (!accessor || accessor.bufferView === void 0 || accessor.sparse)
+            continue;
+          const view = json.bufferViews[accessor.bufferView];
+          gl.bindBuffer(
+            gl.ARRAY_BUFFER,
+            viewBuffer(accessor.bufferView, gl.ARRAY_BUFFER)
+          );
+          gl.enableVertexAttribArray(location);
+          gl.vertexAttribPointer(
+            location,
+            componentsOf(accessor.type),
+            accessor.componentType,
+            Boolean(accessor.normalized),
+            view.byteStride ?? 0,
+            accessor.byteOffset ?? 0
+          );
+          if (name === "NORMAL") flags |= FLAGS.normals;
+        }
+        const indices = primitive.indices !== void 0 ? (_d = json.accessors) == null ? void 0 : _d[primitive.indices] : void 0;
+        if ((indices == null ? void 0 : indices.bufferView) !== void 0)
+          gl.bindBuffer(
+            gl.ELEMENT_ARRAY_BUFFER,
+            viewBuffer(indices.bufferView, gl.ELEMENT_ARRAY_BUFFER)
+          );
+        gl.bindVertexArray(null);
+        const model = multiply(placement, world);
+        const own = material(primitive.material);
+        draws.push({
+          vao,
+          mode: primitive.mode ?? gl.TRIANGLES,
+          count: indices ? indices.count : json.accessors[position].count,
+          ...(indices == null ? void 0 : indices.bufferView) !== void 0 ? {
+            index: {
+              type: indices.componentType,
+              offset: indices.byteOffset ?? 0
+            }
+          } : {},
+          model,
+          normal: normalMatrix(model),
+          mirrored: determinant(model) < 0,
+          material: { ...own, flags: own.flags | flags }
+        });
+        growBox(box, asset, position, model);
+      }
+      for (const child of node.children ?? []) visit(child, world);
+    };
+    const scene = (_a = json.scenes) == null ? void 0 : _a[json.scene ?? 0];
+    const roots = (scene == null ? void 0 : scene.nodes) ?? (json.nodes ?? []).map((_, index) => index).filter(
+      (index) => !json.nodes.some((node) => {
+        var _a2;
+        return (_a2 = node.children) == null ? void 0 : _a2.includes(index);
+      })
+    );
+    const start = new Float32Array([
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1
+    ]);
+    roots.forEach((index) => visit(index, start));
+    draws.sort((a, b) => Number(a.material.blend) - Number(b.material.blend));
+  }
+  function draw(viewProjection, eye, width, height) {
+    gl.viewport(0, 0, width, height);
+    gl.clearColor(0, 0, 0, 0);
+    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+    gl.enable(gl.DEPTH_TEST);
+    gl.useProgram(program);
+    gl.uniformMatrix4fv(u.uViewProjection, false, viewProjection);
+    gl.uniform3fv(u.uCamera, eye);
+    for (const each of draws) {
+      const { material } = each;
+      if (material.doubleSided) gl.disable(gl.CULL_FACE);
+      else gl.enable(gl.CULL_FACE);
+      gl.frontFace(each.mirrored ? gl.CW : gl.CCW);
+      if (material.blend) {
+        gl.enable(gl.BLEND);
+        gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+        gl.depthMask(false);
+      } else {
+        gl.disable(gl.BLEND);
+        gl.depthMask(true);
+      }
+      material.textures.forEach((texture, unit) => {
+        gl.activeTexture(gl.TEXTURE0 + unit);
+        gl.bindTexture(gl.TEXTURE_2D, texture ?? white);
+      });
+      gl.uniformMatrix4fv(u.uModel, false, each.model);
+      gl.uniformMatrix3fv(u.uNormalMatrix, false, each.normal);
+      gl.uniform4fv(u.uBaseColor, material.base);
+      gl.uniform3fv(u.uSpecular, material.specular);
+      gl.uniform1f(u.uMetallic, material.metallic);
+      gl.uniform1f(u.uRoughness, material.roughness);
+      gl.uniform1f(u.uNormalScale, material.normalScale);
+      gl.uniform1f(u.uOcclusionStrength, material.occlusion);
+      gl.uniform3fv(u.uEmissive, material.emissive);
+      gl.uniform1f(u.uAlphaCutoff, material.cutoff);
+      gl.uniform1i(u.uFlags, material.flags);
+      gl.bindVertexArray(each.vao);
+      if (each.index)
+        gl.drawElements(
+          each.mode,
+          each.count,
+          each.index.type,
+          each.index.offset
+        );
+      else gl.drawArrays(each.mode, 0, each.count);
+    }
+    gl.bindVertexArray(null);
+    gl.depthMask(true);
+  }
+  return {
+    add,
+    bounds: () => draws.length ? box : null,
+    draw,
+    dispose() {
+      draws.forEach((each) => gl.deleteVertexArray(each.vao));
+      buffers.forEach((buffer) => gl.deleteBuffer(buffer));
+      textures.forEach((texture) => gl.deleteTexture(texture));
+      gl.deleteProgram(program);
+      draws.length = 0;
+    }
+  };
+}
+function determinant(m) {
+  return m[0] * (m[5] * m[10] - m[6] * m[9]) - m[4] * (m[1] * m[10] - m[2] * m[9]) + m[8] * (m[1] * m[6] - m[2] * m[5]);
+}
+export {
+  createModelRenderer
+};

package/dist/lib/gltf/shaders.mjs

@@ -0,0 +1,192 @@
+"use client";
+const FLAGS = {
+  normals: 1,
+  normalMap: 2,
+  unlit: 4,
+  mask: 8
+};
+const ATTRIBUTES = {
+  POSITION: 0,
+  NORMAL: 1,
+  TEXCOORD_0: 2,
+  COLOR_0: 3
+};
+const TEXTURES = [
+  "uBaseTexture",
+  "uMetalRoughTexture",
+  "uNormalTexture",
+  "uOcclusionTexture",
+  "uEmissiveTexture"
+];
+const VERTEX = `#version 300 es
+layout(location = 0) in vec3 aPosition;
+layout(location = 1) in vec3 aNormal;
+layout(location = 2) in vec2 aUv;
+layout(location = 3) in vec4 aColor;
+uniform mat4 uModel;
+uniform mat4 uViewProjection;
+uniform mat3 uNormalMatrix;
+out vec3 vWorld;
+out vec3 vNormal;
+out vec2 vUv;
+out vec4 vColor;
+void main() {
+  vec4 world = uModel * vec4(aPosition, 1.0);
+  vWorld = world.xyz;
+  vNormal = uNormalMatrix * aNormal;
+  vUv = aUv;
+  vColor = aColor;
+  gl_Position = uViewProjection * world;
+}`;
+const FRAGMENT = `#version 300 es
+precision highp float;
+in vec3 vWorld;
+in vec3 vNormal;
+in vec2 vUv;
+in vec4 vColor;
+uniform vec3 uCamera;
+uniform vec4 uBaseColor;
+uniform vec3 uSpecular;
+uniform float uMetallic;
+uniform float uRoughness;
+uniform float uNormalScale;
+uniform float uOcclusionStrength;
+uniform vec3 uEmissive;
+uniform float uAlphaCutoff;
+uniform int uFlags;
+uniform sampler2D uBaseTexture;
+uniform sampler2D uMetalRoughTexture;
+uniform sampler2D uNormalTexture;
+uniform sampler2D uOcclusionTexture;
+uniform sampler2D uEmissiveTexture;
+out vec4 outColor;
+
+const float PI = 3.14159265;
+const float LAMP = 3.0;
+// The room: a sky and a ground for the light all around, and three lights in it.
+const vec3 SKY = vec3(0.73);
+const vec3 GROUND = vec3(0.58);
+const vec3 LIGHTS[3] = vec3[3](
+  normalize(vec3(0.3, 0.7, 0.9)),
+  normalize(vec3(-0.8, 0.35, 0.5)),
+  normalize(vec3(0.2, 0.4, -1.0))
+);
+const vec3 RADIANCE[3] = vec3[3](vec3(1.2), vec3(0.3), vec3(0.4));
+
+vec3 room(vec3 direction) {
+  return mix(GROUND, SKY, direction.y * 0.5 + 0.5);
+}
+
+// What a surface reflects of the room: its sky and ground, and its lamps, soft panels a
+// glossy surface mirrors and a rough one only glows with.
+const vec3 LAMPS[3] = vec3[3](
+  normalize(vec3(0.0, 1.0, 0.3)),
+  normalize(vec3(-1.0, 0.5, 0.4)),
+  normalize(vec3(1.0, 0.35, -0.3))
+);
+vec3 reflected(vec3 direction, float roughness) {
+  vec3 color = room(direction);
+  float spread = mix(0.04, 0.9, roughness);
+  for (int i = 0; i < 3; i++) {
+    float c = dot(direction, LAMPS[i]);
+    color += vec3(LAMP) * smoothstep(1.0 - spread, 1.0 - spread * 0.35, c) * (1.0 - 0.85 * roughness);
+  }
+  return color;
+}
+
+// A normal map's normal, in the frame its texture coordinates make (no tangents read).
+vec3 mapped(vec3 n) {
+  vec3 tangentNormal = texture(uNormalTexture, vUv).xyz * 2.0 - 1.0;
+  tangentNormal.xy *= vec2(uNormalScale, -uNormalScale);
+  vec3 dp1 = dFdx(vWorld);
+  vec3 dp2 = dFdy(vWorld);
+  vec2 duv1 = dFdx(vUv);
+  vec2 duv2 = dFdy(vUv);
+  vec3 dp2perp = cross(dp2, n);
+  vec3 dp1perp = cross(n, dp1);
+  vec3 t = dp2perp * duv1.x + dp1perp * duv2.x;
+  vec3 b = dp2perp * duv1.y + dp1perp * duv2.y;
+  float scale = inversesqrt(max(dot(t, t), dot(b, b)) + 1e-12);
+  return normalize(mat3(t * scale, b * scale, n) * tangentNormal);
+}
+
+vec3 neutral(vec3 color) {
+  const float start = 0.8 - 0.04;
+  const float desaturation = 0.15;
+  float x = min(color.r, min(color.g, color.b));
+  float offset = x < 0.08 ? x - 6.25 * x * x : 0.04;
+  color -= offset;
+  float peak = max(color.r, max(color.g, color.b));
+  if (peak < start) return color;
+  float d = 1.0 - start;
+  float newPeak = 1.0 - d * d / (peak + d - start);
+  color *= newPeak / peak;
+  float g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);
+  return mix(color, vec3(newPeak), g);
+}
+
+vec3 srgb(vec3 linear) {
+  return mix(
+    linear * 12.92,
+    1.055 * pow(linear, vec3(1.0 / 2.4)) - 0.055,
+    step(0.0031308, linear)
+  );
+}
+
+void main() {
+  vec4 base = uBaseColor * texture(uBaseTexture, vUv) * vColor;
+  if ((uFlags & ${FLAGS.mask}) != 0 && base.a < uAlphaCutoff) discard;
+  if ((uFlags & ${FLAGS.unlit}) != 0) {
+    outColor = vec4(srgb(base.rgb) * base.a, base.a);
+    return;
+  }
+  // No normals given: the face's own, as glTF asks.
+  vec3 n = (uFlags & ${FLAGS.normals}) != 0
+    ? normalize(vNormal)
+    : normalize(cross(dFdx(vWorld), dFdy(vWorld)));
+  if (!gl_FrontFacing) n = -n;
+  if ((uFlags & ${FLAGS.normalMap}) != 0) n = mapped(n);
+  vec3 v = normalize(uCamera - vWorld);
+  vec4 metalRough = texture(uMetalRoughTexture, vUv);
+  float roughness = clamp(uRoughness * metalRough.g, 0.045, 1.0);
+  float metallic = clamp(uMetallic * metalRough.b, 0.0, 1.0);
+  vec3 diffuse = base.rgb * (1.0 - metallic);
+  vec3 f0 = mix(uSpecular, base.rgb, metallic);
+  float a = roughness * roughness;
+  float nv = clamp(dot(n, v), 1e-4, 1.0);
+  vec3 color = vec3(0.0);
+  for (int i = 0; i < 3; i++) {
+    vec3 l = LIGHTS[i];
+    float nl = clamp(dot(n, l), 0.0, 1.0);
+    if (nl <= 0.0) continue;
+    vec3 h = normalize(l + v);
+    float nh = clamp(dot(n, h), 0.0, 1.0);
+    float vh = clamp(dot(v, h), 0.0, 1.0);
+    float a2 = a * a;
+    float dd = nh * nh * (a2 - 1.0) + 1.0;
+    float distribution = a2 / (PI * dd * dd);
+    float viewed = nl * sqrt(nv * nv * (1.0 - a2) + a2);
+    float lit = nv * sqrt(nl * nl * (1.0 - a2) + a2);
+    float visibility = 0.5 / (viewed + lit + 1e-5);
+    vec3 fresnel = f0 + (1.0 - f0) * pow(1.0 - vh, 5.0);
+    vec3 specular = fresnel * distribution * visibility;
+    color += ((1.0 - fresnel) * diffuse + PI * specular) * RADIANCE[i] * nl;
+  }
+  // The room's light all around: diffuse, and what a rough or smooth surface reflects of it.
+  vec4 c0 = vec4(-1.0, -0.0275, -0.572, 0.022);
+  vec4 c1 = vec4(1.0, 0.0425, 1.04, -0.04);
+  vec4 r = roughness * c0 + c1;
+  float a004 = min(r.x * r.x, exp2(-9.28 * nv)) * r.x + r.y;
+  vec2 ab = vec2(-1.04, 1.04) * a004 + r.zw;
+  float occlusion = mix(1.0, texture(uOcclusionTexture, vUv).r, uOcclusionStrength);
+  color += (diffuse * room(n) + (f0 * ab.x + ab.y) * reflected(reflect(-v, n), roughness)) * occlusion;
+  color += uEmissive * texture(uEmissiveTexture, vUv).rgb;
+  outColor = vec4(srgb(neutral(color)) * base.a, base.a);
+}`;
+export {
+  ATTRIBUTES,
+  FLAGS,
+  FRAGMENT,
+  TEXTURES,
+  VERTEX
+};

package/dist/lib/hls.mjs

@@ -0,0 +1,6 @@
+"use client";
+const HLS_TYPE = /^((application|audio|video)\/)?(vnd\.apple\.|x-)?mpegurl$/i;
+const isHls = (id, format) => Boolean(id && /\.m3u8$/i.test(id.split(/[?#]/)[0])) || Boolean(format && HLS_TYPE.test(format));
+export {
+  isHls
+};

package/dist/lib/pointer.mjs

@@ -0,0 +1,38 @@
+"use client";
+const TAP_SLOP = 5;
+const TAP_MS = 300;
+const DOUBLE_TAP_SLOP = TAP_SLOP * 4;
+function isDirect(pointerType, hovers = false) {
+  return pointerType === "touch" || pointerType === "pen" && !hovers;
+}
+function isHovering(event) {
+  return event.pointerType === "pen" && event.buttons === 0;
+}
+function scrollsWithin(target, bodyBox, deltaY) {
+  for (let node = target; node && node !== bodyBox; node = node.parentElement) {
+    const room = deltaY > 0 ? node.scrollHeight - node.clientHeight - node.scrollTop : node.scrollTop;
+    if (room >= 1 && /auto|scroll/.test(getComputedStyle(node).overflowY))
+      return true;
+  }
+  return false;
+}
+function isInteractive(target, bodyBox) {
+  var _a;
+  let node = target;
+  while (node && node !== bodyBox) {
+    if (node instanceof HTMLButtonElement || node instanceof HTMLAnchorElement || node instanceof HTMLInputElement || node instanceof HTMLSelectElement || ((_a = node.dataset) == null ? void 0 : _a.cloverCanvasInteractive) !== void 0) {
+      return true;
+    }
+    node = node.parentElement;
+  }
+  return false;
+}
+export {
+  DOUBLE_TAP_SLOP,
+  TAP_MS,
+  TAP_SLOP,
+  isDirect,
+  isHovering,
+  isInteractive,
+  scrollsWithin
+};