three-text 0.4.11 → 0.5.0

package/dist/patterns/index.js

@@ -10,7 +10,6 @@ export const availablePatterns = [
   'bg',
   'bn',
   'ca',
-  'cs',
   'cy',
   'da',
   'de-1996',
@@ -34,7 +33,6 @@ export const availablePatterns = [
   'hu',
   'hy',
   'ia',
-  'id',
   'is',
   'it',
   'ka',
@@ -43,7 +41,6 @@ export const availablePatterns = [
   'la',
   'lt',
   'lv',
-  'mk',
   'ml',
   'mn-cyrl',
   'mr',
@@ -66,7 +63,6 @@ export const availablePatterns = [
   'sk',
   'sl',
   'sq',
-  'sr-cyrl',
   'sv',
   'ta',
   'te',

package/dist/slug/index.cjs

@@ -0,0 +1,380 @@
+'use strict';
+
+var vertGLSL = "#version 300 es\n// ===================================================\n// GLSL 300 es port of the reference Slug vertex shader.\n// Original HLSL by Eric Lengyel, MIT License, Copyright 2017.\n// See: https://jcgt.org/published/0006/02/02/\n// ===================================================\n\nprecision highp float;\nprecision highp int;\n\n// Per-vertex attributes (5 x vec4, matching Slug reference layout)\nlayout(location = 0) in vec4 a_pos; // .xy = object-space position, .zw = outward normal\nlayout(location = 1) in vec4 a_tex; // .xy = em-space sample coords, .z = packed glyph loc, .w = packed band max + flags\nlayout(location = 2) in vec4 a_jac; // inverse Jacobian (2x2): (j00, j01, j10, j11)\nlayout(location = 3) in vec4 a_bnd; // (bandScaleX, bandScaleY, bandOffsetX, bandOffsetY)\nlayout(location = 4) in vec4 a_col; // vertex color RGBA\n\nuniform mat4 slug_matrix;    // MVP matrix (rows as vec4s)\nuniform vec2 slug_viewport;  // viewport dimensions in pixels\n\nout vec4 v_color;\nout vec2 v_texcoord;\nflat out vec4 v_banding;\nflat out ivec4 v_glyph;\n\nvoid SlugUnpack(vec4 tex, vec4 bnd, out vec4 vbnd, out ivec4 vgly) {\n    uvec2 g = floatBitsToUint(tex.zw);\n    vgly = ivec4(g.x & 0xFFFFu, g.x >> 16u, g.y & 0xFFFFu, g.y >> 16u);\n    vbnd = bnd;\n}\n\nvec2 SlugDilate(vec4 pos, vec4 tex, vec4 jac, vec4 m0, vec4 m1, vec4 m3, vec2 dim, out vec2 vpos) {\n    vec2 n = normalize(pos.zw);\n    float s = dot(m3.xy, pos.xy) + m3.w;\n    float t = dot(m3.xy, n);\n\n    float u = (s * dot(m0.xy, n) - t * (dot(m0.xy, pos.xy) + m0.w)) * dim.x;\n    float v = (s * dot(m1.xy, n) - t * (dot(m1.xy, pos.xy) + m1.w)) * dim.y;\n\n    float s2 = s * s;\n    float st = s * t;\n    float uv = u * u + v * v;\n    vec2 d = pos.zw * (s2 * (st + sqrt(uv)) / (uv - st * st));\n\n    vpos = pos.xy + d;\n    return vec2(tex.x + dot(d, jac.xy), tex.y + dot(d, jac.zw));\n}\n\nvoid main() {\n    vec2 p;\n\n    // Dynamic dilation: expand quad by a pixel to prevent edge clipping.\n    v_texcoord = SlugDilate(a_pos, a_tex, a_jac,\n                            slug_matrix[0], slug_matrix[1], slug_matrix[3],\n                            slug_viewport, p);\n\n    // MVP transform on dilated position.\n    gl_Position.x = p.x * slug_matrix[0].x + p.y * slug_matrix[0].y + slug_matrix[0].w;\n    gl_Position.y = p.x * slug_matrix[1].x + p.y * slug_matrix[1].y + slug_matrix[1].w;\n    gl_Position.z = p.x * slug_matrix[2].x + p.y * slug_matrix[2].y + slug_matrix[2].w;\n    gl_Position.w = p.x * slug_matrix[3].x + p.y * slug_matrix[3].y + slug_matrix[3].w;\n\n    SlugUnpack(a_tex, a_bnd, v_banding, v_glyph);\n    v_color = a_col;\n}\n";
+
+var fragGLSL = "#version 300 es\n// ===================================================\n// GLSL 300 es port of the reference Slug pixel shader.\n// Original HLSL by Eric Lengyel, MIT License, Copyright 2017.\n// See: https://jcgt.org/published/0006/02/02/\n// ===================================================\n\nprecision highp float;\nprecision highp int;\n\n#define kLogBandTextureWidth 12\n\nin vec4 v_color;\nin vec2 v_texcoord;\nflat in vec4 v_banding;\nflat in ivec4 v_glyph;\n\nuniform sampler2D curveTexture;     // RGBA32F control points\nuniform highp usampler2D bandTexture; // RGBA32UI band data\n\nlayout(location = 0) out vec4 outColor;\n\nuint CalcRootCode(float y1, float y2, float y3) {\n    uint i1 = floatBitsToUint(y1) >> 31u;\n    uint i2 = floatBitsToUint(y2) >> 30u;\n    uint i3 = floatBitsToUint(y3) >> 29u;\n\n    uint shift = (i2 & 2u) | (i1 & ~2u);\n    shift = (i3 & 4u) | (shift & ~4u);\n\n    return (0x2E74u >> shift) & 0x0101u;\n}\n\nvec2 SolveHorizPoly(vec4 p12, vec2 p3) {\n    vec2 a = p12.xy - p12.zw * 2.0 + p3;\n    vec2 b = p12.xy - p12.zw;\n    float ra = 1.0 / a.y;\n    float rb = 0.5 / b.y;\n\n    float d = sqrt(max(b.y * b.y - a.y * p12.y, 0.0));\n    float t1 = (b.y - d) * ra;\n    float t2 = (b.y + d) * ra;\n\n    if (abs(a.y) < 1.0 / 65536.0) t1 = t2 = p12.y * rb;\n\n    return vec2((a.x * t1 - b.x * 2.0) * t1 + p12.x, (a.x * t2 - b.x * 2.0) * t2 + p12.x);\n}\n\nvec2 SolveVertPoly(vec4 p12, vec2 p3) {\n    vec2 a = p12.xy - p12.zw * 2.0 + p3;\n    vec2 b = p12.xy - p12.zw;\n    float ra = 1.0 / a.x;\n    float rb = 0.5 / b.x;\n\n    float d = sqrt(max(b.x * b.x - a.x * p12.x, 0.0));\n    float t1 = (b.x - d) * ra;\n    float t2 = (b.x + d) * ra;\n\n    if (abs(a.x) < 1.0 / 65536.0) t1 = t2 = p12.x * rb;\n\n    return vec2((a.y * t1 - b.y * 2.0) * t1 + p12.y, (a.y * t2 - b.y * 2.0) * t2 + p12.y);\n}\n\nivec2 CalcBandLoc(ivec2 glyphLoc, uint offset) {\n    ivec2 bandLoc = ivec2(glyphLoc.x + int(offset), glyphLoc.y);\n    bandLoc.y += bandLoc.x >> kLogBandTextureWidth;\n    bandLoc.x &= (1 << kLogBandTextureWidth) - 1;\n    return bandLoc;\n}\n\nfloat CalcCoverage(float xcov, float ycov, float xwgt, float ywgt, int flags) {\n    float coverage = max(abs(xcov * xwgt + ycov * ywgt) / max(xwgt + ywgt, 1.0 / 65536.0), min(abs(xcov), abs(ycov)));\n\n#if defined(SLUG_EVENODD)\n    if ((flags & 0x1000) == 0) {\n#endif\n        coverage = clamp(coverage, 0.0, 1.0);\n#if defined(SLUG_EVENODD)\n    } else {\n        coverage = 1.0 - abs(1.0 - fract(coverage * 0.5) * 2.0);\n    }\n#endif\n\n#if defined(SLUG_WEIGHT)\n    coverage = sqrt(coverage);\n#endif\n\n    return coverage;\n}\n\nfloat SlugRender(vec2 renderCoord, vec4 bandTransform, ivec4 glyphData) {\n    int curveIndex;\n\n    vec2 emsPerPixel = fwidth(renderCoord);\n    vec2 pixelsPerEm = 1.0 / emsPerPixel;\n\n    ivec2 bandMax = glyphData.zw;\n    bandMax.y &= 0x00FF;\n\n    ivec2 bandIndex = clamp(ivec2(renderCoord * bandTransform.xy + bandTransform.zw), ivec2(0, 0), bandMax);\n    ivec2 glyphLoc = glyphData.xy;\n\n    float xcov = 0.0;\n    float xwgt = 0.0;\n\n    uvec2 hbandData = texelFetch(bandTexture, ivec2(glyphLoc.x + bandIndex.y, glyphLoc.y), 0).xy;\n    ivec2 hbandLoc = CalcBandLoc(glyphLoc, hbandData.y);\n\n    for (curveIndex = 0; curveIndex < int(hbandData.x); curveIndex++) {\n        ivec2 curveLoc = ivec2(texelFetch(bandTexture, ivec2(hbandLoc.x + curveIndex, hbandLoc.y), 0).xy);\n\n        vec4 p12 = texelFetch(curveTexture, curveLoc, 0) - vec4(renderCoord, renderCoord);\n        vec2 p3 = texelFetch(curveTexture, ivec2(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.x, p12.z), p3.x) * pixelsPerEm.x < -0.5) break;\n\n        uint code = CalcRootCode(p12.y, p12.w, p3.y);\n        if (code != 0u) {\n            vec2 r = SolveHorizPoly(p12, p3) * pixelsPerEm.x;\n\n            if ((code & 1u) != 0u) {\n                xcov += clamp(r.x + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n\n            if (code > 1u) {\n                xcov -= clamp(r.y + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    float ycov = 0.0;\n    float ywgt = 0.0;\n\n    uvec2 vbandData = texelFetch(bandTexture, ivec2(glyphLoc.x + bandMax.y + 1 + bandIndex.x, glyphLoc.y), 0).xy;\n    ivec2 vbandLoc = CalcBandLoc(glyphLoc, vbandData.y);\n\n    for (curveIndex = 0; curveIndex < int(vbandData.x); curveIndex++) {\n        ivec2 curveLoc = ivec2(texelFetch(bandTexture, ivec2(vbandLoc.x + curveIndex, vbandLoc.y), 0).xy);\n        vec4 p12 = texelFetch(curveTexture, curveLoc, 0) - vec4(renderCoord, renderCoord);\n        vec2 p3 = texelFetch(curveTexture, ivec2(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.y, p12.w), p3.y) * pixelsPerEm.y < -0.5) break;\n\n        uint code = CalcRootCode(p12.x, p12.z, p3.x);\n        if (code != 0u) {\n            vec2 r = SolveVertPoly(p12, p3) * pixelsPerEm.y;\n\n            if ((code & 1u) != 0u) {\n                ycov -= clamp(r.x + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n\n            if (code > 1u) {\n                ycov += clamp(r.y + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    return CalcCoverage(xcov, ycov, xwgt, ywgt, glyphData.w);\n}\n\nvoid main() {\n    float coverage = SlugRender(v_texcoord, v_banding, v_glyph);\n    outColor = v_color * coverage;\n}\n";
+
+var vertWGSL = "// ===================================================\n// WGSL port of the reference Slug vertex shader.\n// Original HLSL by Eric Lengyel, MIT License, Copyright 2017.\n// See: https://jcgt.org/published/0006/02/02/\n// ===================================================\n\nstruct Uniforms {\n    slug_matrix: mat4x4<f32>,\n    slug_viewport: vec2<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: Uniforms;\n\nstruct VertexInput {\n    @location(0) a_pos: vec4<f32>,\n    @location(1) a_tex: vec4<f32>,\n    @location(2) a_jac: vec4<f32>,\n    @location(3) a_bnd: vec4<f32>,\n    @location(4) a_col: vec4<f32>,\n};\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) color: vec4<f32>,\n    @location(1) texcoord: vec2<f32>,\n    @location(2) @interpolate(flat) banding: vec4<f32>,\n    @location(3) @interpolate(flat) glyph: vec4<i32>,\n};\n\nfn SlugUnpack(tex: vec4<f32>, bnd: vec4<f32>) -> VertexOutput {\n    var out: VertexOutput;\n    let g = bitcast<vec2<u32>>(tex.zw);\n    out.glyph = vec4<i32>(\n        i32(g.x & 0xFFFFu),\n        i32(g.x >> 16u),\n        i32(g.y & 0xFFFFu),\n        i32(g.y >> 16u)\n    );\n    out.banding = bnd;\n    return out;\n}\n\nfn SlugDilate(\n    pos: vec4<f32>, tex: vec4<f32>, jac: vec4<f32>,\n    m0: vec4<f32>, m1: vec4<f32>, m3: vec4<f32>,\n    dim: vec2<f32>\n) -> vec4<f32> {\n    // Returns vec4(dilated_pos.xy, new_texcoord.xy)\n    let n = normalize(pos.zw);\n    let s = dot(m3.xy, pos.xy) + m3.w;\n    let t = dot(m3.xy, n);\n\n    let u_val = (s * dot(m0.xy, n) - t * (dot(m0.xy, pos.xy) + m0.w)) * dim.x;\n    let v_val = (s * dot(m1.xy, n) - t * (dot(m1.xy, pos.xy) + m1.w)) * dim.y;\n\n    let s2 = s * s;\n    let st = s * t;\n    let uv = u_val * u_val + v_val * v_val;\n    let d = pos.zw * (s2 * (st + sqrt(uv)) / (uv - st * st));\n\n    let vpos = pos.xy + d;\n    let vtex = vec2<f32>(tex.x + dot(d, jac.xy), tex.y + dot(d, jac.zw));\n    return vec4<f32>(vpos, vtex);\n}\n\n@vertex\nfn vs_main(in: VertexInput) -> VertexOutput {\n    let dilated = SlugDilate(\n        in.a_pos, in.a_tex, in.a_jac,\n        u.slug_matrix[0], u.slug_matrix[1], u.slug_matrix[3],\n        u.slug_viewport\n    );\n\n    let p = dilated.xy;\n    var out = SlugUnpack(in.a_tex, in.a_bnd);\n\n    out.position = vec4<f32>(\n        p.x * u.slug_matrix[0].x + p.y * u.slug_matrix[0].y + u.slug_matrix[0].w,\n        p.x * u.slug_matrix[1].x + p.y * u.slug_matrix[1].y + u.slug_matrix[1].w,\n        p.x * u.slug_matrix[2].x + p.y * u.slug_matrix[2].y + u.slug_matrix[2].w,\n        p.x * u.slug_matrix[3].x + p.y * u.slug_matrix[3].y + u.slug_matrix[3].w\n    );\n\n    out.texcoord = dilated.zw;\n    out.color = in.a_col;\n    return out;\n}\n";
+
+var fragWGSL = "// ===================================================\n// WGSL port of the reference Slug pixel shader.\n// Original HLSL by Eric Lengyel, MIT License, Copyright 2017.\n// See: https://jcgt.org/published/0006/02/02/\n// ===================================================\n\nconst kLogBandTextureWidth: u32 = 12u;\n\n@group(0) @binding(1) var curveTexture: texture_2d<f32>;\n@group(0) @binding(2) var bandTexture: texture_2d<u32>;\n\nstruct FragmentInput {\n    @location(0) color: vec4<f32>,\n    @location(1) texcoord: vec2<f32>,\n    @location(2) @interpolate(flat) banding: vec4<f32>,\n    @location(3) @interpolate(flat) glyph: vec4<i32>,\n};\n\nfn CalcRootCode(y1: f32, y2: f32, y3: f32) -> u32 {\n    let i1 = bitcast<u32>(y1) >> 31u;\n    let i2 = bitcast<u32>(y2) >> 30u;\n    let i3 = bitcast<u32>(y3) >> 29u;\n\n    var shift = (i2 & 2u) | (i1 & ~2u);\n    shift = (i3 & 4u) | (shift & ~4u);\n\n    return (0x2E74u >> shift) & 0x0101u;\n}\n\nfn SolveHorizPoly(p12: vec4<f32>, p3: vec2<f32>) -> vec2<f32> {\n    let a = p12.xy - p12.zw * 2.0 + p3;\n    let b = p12.xy - p12.zw;\n    let ra = 1.0 / a.y;\n    let rb = 0.5 / b.y;\n\n    let d = sqrt(max(b.y * b.y - a.y * p12.y, 0.0));\n    var t1 = (b.y - d) * ra;\n    var t2 = (b.y + d) * ra;\n\n    if (abs(a.y) < 1.0 / 65536.0) {\n        t1 = p12.y * rb;\n        t2 = t1;\n    }\n\n    return vec2<f32>(\n        (a.x * t1 - b.x * 2.0) * t1 + p12.x,\n        (a.x * t2 - b.x * 2.0) * t2 + p12.x\n    );\n}\n\nfn SolveVertPoly(p12: vec4<f32>, p3: vec2<f32>) -> vec2<f32> {\n    let a = p12.xy - p12.zw * 2.0 + p3;\n    let b = p12.xy - p12.zw;\n    let ra = 1.0 / a.x;\n    let rb = 0.5 / b.x;\n\n    let d = sqrt(max(b.x * b.x - a.x * p12.x, 0.0));\n    var t1 = (b.x - d) * ra;\n    var t2 = (b.x + d) * ra;\n\n    if (abs(a.x) < 1.0 / 65536.0) {\n        t1 = p12.x * rb;\n        t2 = t1;\n    }\n\n    return vec2<f32>(\n        (a.y * t1 - b.y * 2.0) * t1 + p12.y,\n        (a.y * t2 - b.y * 2.0) * t2 + p12.y\n    );\n}\n\nfn CalcBandLoc(glyphLoc: vec2<i32>, offset: u32) -> vec2<i32> {\n    var bandLoc = vec2<i32>(glyphLoc.x + i32(offset), glyphLoc.y);\n    bandLoc.y += bandLoc.x >> i32(kLogBandTextureWidth);\n    bandLoc.x &= (1 << i32(kLogBandTextureWidth)) - 1;\n    return bandLoc;\n}\n\nfn CalcCoverage(xcov: f32, ycov: f32, xwgt: f32, ywgt: f32) -> f32 {\n    var coverage = max(\n        abs(xcov * xwgt + ycov * ywgt) / max(xwgt + ywgt, 1.0 / 65536.0),\n        min(abs(xcov), abs(ycov))\n    );\n    coverage = clamp(coverage, 0.0, 1.0);\n    return coverage;\n}\n\nfn SlugRender(renderCoord: vec2<f32>, bandTransform: vec4<f32>, glyphData: vec4<i32>) -> f32 {\n    let emsPerPixel = fwidth(renderCoord);\n    let pixelsPerEm = 1.0 / emsPerPixel;\n\n    var bandMax = glyphData.zw;\n    bandMax.y &= 0x00FF;\n\n    let bandIndex = clamp(\n        vec2<i32>(renderCoord * bandTransform.xy + bandTransform.zw),\n        vec2<i32>(0, 0),\n        bandMax\n    );\n    let glyphLoc = glyphData.xy;\n\n    var xcov = 0.0;\n    var xwgt = 0.0;\n\n    let hbandData = textureLoad(bandTexture, vec2<i32>(glyphLoc.x + bandIndex.y, glyphLoc.y), 0).xy;\n    let hbandLoc = CalcBandLoc(glyphLoc, hbandData.y);\n\n    for (var ci = 0; ci < i32(hbandData.x); ci++) {\n        let curveLoc = vec2<i32>(textureLoad(bandTexture, vec2<i32>(hbandLoc.x + ci, hbandLoc.y), 0).xy);\n\n        let p12 = textureLoad(curveTexture, curveLoc, 0) - vec4<f32>(renderCoord, renderCoord);\n        let p3 = textureLoad(curveTexture, vec2<i32>(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.x, p12.z), p3.x) * pixelsPerEm.x < -0.5) { break; }\n\n        let code = CalcRootCode(p12.y, p12.w, p3.y);\n        if (code != 0u) {\n            let r = SolveHorizPoly(p12, p3) * pixelsPerEm.x;\n\n            if ((code & 1u) != 0u) {\n                xcov += clamp(r.x + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n            if (code > 1u) {\n                xcov -= clamp(r.y + 0.5, 0.0, 1.0);\n                xwgt = max(xwgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    var ycov = 0.0;\n    var ywgt = 0.0;\n\n    let vbandData = textureLoad(bandTexture, vec2<i32>(glyphLoc.x + bandMax.y + 1 + bandIndex.x, glyphLoc.y), 0).xy;\n    let vbandLoc = CalcBandLoc(glyphLoc, vbandData.y);\n\n    for (var ci = 0; ci < i32(vbandData.x); ci++) {\n        let curveLoc = vec2<i32>(textureLoad(bandTexture, vec2<i32>(vbandLoc.x + ci, vbandLoc.y), 0).xy);\n        let p12 = textureLoad(curveTexture, curveLoc, 0) - vec4<f32>(renderCoord, renderCoord);\n        let p3 = textureLoad(curveTexture, vec2<i32>(curveLoc.x + 1, curveLoc.y), 0).xy - renderCoord;\n\n        if (max(max(p12.y, p12.w), p3.y) * pixelsPerEm.y < -0.5) { break; }\n\n        let code = CalcRootCode(p12.x, p12.z, p3.x);\n        if (code != 0u) {\n            let r = SolveVertPoly(p12, p3) * pixelsPerEm.y;\n\n            if ((code & 1u) != 0u) {\n                ycov -= clamp(r.x + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.x) * 2.0, 0.0, 1.0));\n            }\n            if (code > 1u) {\n                ycov += clamp(r.y + 0.5, 0.0, 1.0);\n                ywgt = max(ywgt, clamp(1.0 - abs(r.y) * 2.0, 0.0, 1.0));\n            }\n        }\n    }\n\n    return CalcCoverage(xcov, ycov, xwgt, ywgt);\n}\n\n@fragment\nfn fs_main(in: FragmentInput) -> @location(0) vec4<f32> {\n    let coverage = SlugRender(in.texcoord, in.banding, in.glyph);\n    return in.color * coverage;\n}\n";
+
+/**
+ * Slug shader source re-exports.
+ * The .glsl/.wgsl files are the single source of truth — imported as strings
+ * at build time via the glslPlugin in rollup.config.js.
+ */
+// @ts-ignore — resolved by rollup glslPlugin
+const vertexShaderGLSL300 = vertGLSL;
+const fragmentShaderGLSL300 = fragGLSL;
+const vertexShaderWGSL = vertWGSL;
+const fragmentShaderWGSL = fragWGSL;
+
+/**
+ * CPU-side data packer for the Slug algorithm.
+ * Faithful to Eric Lengyel's reference layout (MIT License, 2017).
+ *
+ * Takes generic quadratic Bezier shapes (not text-specific) and produces
+ * GPU-ready packed textures + vertex attribute buffers.
+ */
+const TEX_WIDTH = 4096;
+const LOG_TEX_WIDTH = 12;
+// Float ↔ Uint32 reinterpretation helpers
+const _f32 = new Float32Array(1);
+const _u32 = new Uint32Array(_f32.buffer);
+function uintAsFloat(u) {
+    _u32[0] = u;
+    return _f32[0];
+}
+/**
+ * Pack an array of shapes into Slug's GPU data layout.
+ *
+ * Each shape is a closed region defined by quadratic Bezier curves.
+ * Returns textures + vertex buffers ready for GPU upload.
+ */
+function packSlugData(shapes, options) {
+    const bandCount = options?.bandCount ?? 16;
+    const evenOdd = options?.evenOdd ?? false;
+    // Phase 1: Pack all curves into curveTexture
+    const allCurves = [];
+    // Estimate max texels needed
+    let totalCurves = 0;
+    for (const shape of shapes) {
+        totalCurves += shape.curves.length;
+    }
+    const curveTexHeight = Math.ceil((totalCurves * 2) / TEX_WIDTH) + 1;
+    const curveData = new Float32Array(TEX_WIDTH * curveTexHeight * 4);
+    let curveX = 0;
+    let curveY = 0;
+    for (const shape of shapes) {
+        const entries = [];
+        for (const curve of shape.curves) {
+            // Don't let a curve span across row boundary (needs 2 consecutive texels)
+            if (curveX >= TEX_WIDTH - 1) {
+                curveX = 0;
+                curveY++;
+            }
+            const base = (curveY * TEX_WIDTH + curveX) * 4;
+            curveData[base + 0] = curve.p1[0];
+            curveData[base + 1] = curve.p1[1];
+            curveData[base + 2] = curve.p2[0];
+            curveData[base + 3] = curve.p2[1];
+            const base2 = base + 4;
+            curveData[base2 + 0] = curve.p3[0];
+            curveData[base2 + 1] = curve.p3[1];
+            const minX = Math.min(curve.p1[0], curve.p2[0], curve.p3[0]);
+            const minY = Math.min(curve.p1[1], curve.p2[1], curve.p3[1]);
+            const maxX = Math.max(curve.p1[0], curve.p2[0], curve.p3[0]);
+            const maxY = Math.max(curve.p1[1], curve.p2[1], curve.p3[1]);
+            entries.push({
+                p1x: curve.p1[0], p1y: curve.p1[1],
+                p2x: curve.p2[0], p2y: curve.p2[1],
+                p3x: curve.p3[0], p3y: curve.p3[1],
+                minX, minY, maxX, maxY,
+                curveTexX: curveX,
+                curveTexY: curveY
+            });
+            curveX += 2;
+        }
+        allCurves.push(entries);
+    }
+    const actualCurveTexHeight = curveY + 1;
+    // Phase 2: Build band data for each shape and pack into bandTexture
+    // Layout per shape in bandTexture (relative to glyphLoc):
+    //   [0 .. hBandMax]                          : h-band headers
+    //   [hBandMax+1 .. hBandMax+1+vBandMax]      : v-band headers
+    //   [hBandMax+vBandMax+2 .. ]                : curve index lists
+    // First pass: compute total band texels needed
+    const shapeBandData = [];
+    let totalBandTexels = 0;
+    for (let si = 0; si < shapes.length; si++) {
+        const shape = shapes[si];
+        const curves = allCurves[si];
+        if (curves.length === 0) {
+            shapeBandData.push({
+                hBands: [], vBands: [], hLists: [], vLists: [],
+                totalTexels: 0, bandMaxX: 0, bandMaxY: 0
+            });
+            continue;
+        }
+        const [bMinX, bMinY, bMaxX, bMaxY] = shape.bounds;
+        const w = bMaxX - bMinX;
+        const h = bMaxY - bMinY;
+        const hBandCount = Math.min(bandCount, 255); // max 255 (fits in 8 bits)
+        const vBandCount = Math.min(bandCount, 255);
+        const bandMaxY = hBandCount - 1;
+        const bandMaxX = vBandCount - 1;
+        // Build horizontal bands (partition y-axis)
+        const hBands = [];
+        const hLists = [];
+        const bandH = h / hBandCount;
+        for (let bi = 0; bi < hBandCount; bi++) {
+            const bandMinY = bMinY + bi * bandH;
+            const bandMaxYCoord = bandMinY + bandH;
+            // Collect curves whose y-range overlaps this band
+            const list = [];
+            for (const c of curves) {
+                if (c.maxY >= bandMinY && c.minY <= bandMaxYCoord) {
+                    list.push({ curve: c, sortKey: c.maxX });
+                }
+            }
+            // Sort by descending max-x for early exit
+            list.sort((a, b) => b.sortKey - a.sortKey);
+            const flatList = [];
+            for (const item of list) {
+                flatList.push(item.curve.curveTexX, item.curve.curveTexY);
+            }
+            hBands.push({ curveCount: list.length, listOffset: 0 });
+            hLists.push(flatList);
+        }
+        // Build vertical bands (partition x-axis)
+        const vBands = [];
+        const vLists = [];
+        const bandW = w / vBandCount;
+        for (let bi = 0; bi < vBandCount; bi++) {
+            const bandMinX = bMinX + bi * bandW;
+            const bandMaxXCoord = bandMinX + bandW;
+            const list = [];
+            for (const c of curves) {
+                if (c.maxX >= bandMinX && c.minX <= bandMaxXCoord) {
+                    list.push({ curve: c, sortKey: c.maxY });
+                }
+            }
+            // Sort by descending max-y for early exit
+            list.sort((a, b) => b.sortKey - a.sortKey);
+            const flatList = [];
+            for (const item of list) {
+                flatList.push(item.curve.curveTexX, item.curve.curveTexY);
+            }
+            vBands.push({ curveCount: list.length, listOffset: 0 });
+            vLists.push(flatList);
+        }
+        // Total texels for this shape: band headers + curve lists
+        const headerTexels = hBandCount + vBandCount;
+        let listTexels = 0;
+        for (const l of hLists)
+            listTexels += l.length / 2;
+        for (const l of vLists)
+            listTexels += l.length / 2;
+        const total = headerTexels + listTexels;
+        shapeBandData.push({
+            hBands, vBands, hLists, vLists,
+            totalTexels: total, bandMaxX, bandMaxY
+        });
+        totalBandTexels += total;
+    }
+    // Allocate bandTexture
+    const bandTexHeight = Math.max(1, Math.ceil(totalBandTexels / TEX_WIDTH) + shapes.length);
+    const bandData = new Uint32Array(TEX_WIDTH * bandTexHeight * 4);
+    // Pack band data per shape
+    let bandX = 0;
+    let bandY = 0;
+    const glyphLocs = [];
+    for (let si = 0; si < shapes.length; si++) {
+        const sd = shapeBandData[si];
+        if (sd.totalTexels === 0) {
+            glyphLocs.push({ x: 0, y: 0 });
+            continue;
+        }
+        // Ensure glyph data doesn't start too close to row end
+        // (need at least headerTexels contiguous... actually wrapping is handled by CalcBandLoc)
+        // But the initial band header reads don't use CalcBandLoc, so glyphLoc.x + bandMax.y + 1 + bandMaxX
+        // must be reachable. CalcBandLoc handles wrapping for curve lists.
+        // To be safe, start each glyph at the beginning of a row if remaining space is tight.
+        const minContiguous = sd.hBands.length + sd.vBands.length;
+        if (bandX + minContiguous > TEX_WIDTH) {
+            bandX = 0;
+            bandY++;
+        }
+        const glyphLocX = bandX;
+        const glyphLocY = bandY;
+        glyphLocs.push({ x: glyphLocX, y: glyphLocY });
+        // Curve lists start after all headers
+        let listStartOffset = sd.hBands.length + sd.vBands.length;
+        // Assign list offsets for h-bands
+        for (let bi = 0; bi < sd.hBands.length; bi++) {
+            sd.hBands[bi].listOffset = listStartOffset;
+            listStartOffset += sd.hLists[bi].length / 2;
+        }
+        // Assign list offsets for v-bands
+        for (let bi = 0; bi < sd.vBands.length; bi++) {
+            sd.vBands[bi].listOffset = listStartOffset;
+            listStartOffset += sd.vLists[bi].length / 2;
+        }
+        // Write h-band headers
+        for (let bi = 0; bi < sd.hBands.length; bi++) {
+            const tx = glyphLocX + bi;
+            const ty = glyphLocY;
+            const idx = (ty * TEX_WIDTH + tx) * 4;
+            bandData[idx + 0] = sd.hBands[bi].curveCount;
+            bandData[idx + 1] = sd.hBands[bi].listOffset;
+            bandData[idx + 2] = 0;
+            bandData[idx + 3] = 0;
+        }
+        // Write v-band headers (after h-bands)
+        const vBandStart = glyphLocX + sd.hBands.length;
+        for (let bi = 0; bi < sd.vBands.length; bi++) {
+            const tx = vBandStart + bi;
+            const ty = glyphLocY;
+            const idx = (ty * TEX_WIDTH + tx) * 4;
+            bandData[idx + 0] = sd.vBands[bi].curveCount;
+            bandData[idx + 1] = sd.vBands[bi].listOffset;
+            bandData[idx + 2] = 0;
+            bandData[idx + 3] = 0;
+        }
+        // Write curve lists using CalcBandLoc-style wrapping
+        const writeBandLoc = (offset) => {
+            let bx = glyphLocX + offset;
+            let by = glyphLocY;
+            by += bx >> LOG_TEX_WIDTH;
+            bx &= (1 << LOG_TEX_WIDTH) - 1;
+            return { x: bx, y: by };
+        };
+        // Write h-band curve lists
+        for (let bi = 0; bi < sd.hBands.length; bi++) {
+            const list = sd.hLists[bi];
+            const baseOffset = sd.hBands[bi].listOffset;
+            for (let ci = 0; ci < list.length; ci += 2) {
+                const loc = writeBandLoc(baseOffset + ci / 2);
+                const idx = (loc.y * TEX_WIDTH + loc.x) * 4;
+                bandData[idx + 0] = list[ci]; // curveTexX
+                bandData[idx + 1] = list[ci + 1]; // curveTexY
+                bandData[idx + 2] = 0;
+                bandData[idx + 3] = 0;
+            }
+        }
+        // Write v-band curve lists
+        for (let bi = 0; bi < sd.vBands.length; bi++) {
+            const list = sd.vLists[bi];
+            const baseOffset = sd.vBands[bi].listOffset;
+            for (let ci = 0; ci < list.length; ci += 2) {
+                const loc = writeBandLoc(baseOffset + ci / 2);
+                const idx = (loc.y * TEX_WIDTH + loc.x) * 4;
+                bandData[idx + 0] = list[ci];
+                bandData[idx + 1] = list[ci + 1];
+                bandData[idx + 2] = 0;
+                bandData[idx + 3] = 0;
+            }
+        }
+        // Advance band cursor past this shape's data
+        const totalForShape = listStartOffset;
+        const endLoc = writeBandLoc(totalForShape);
+        bandX = endLoc.x;
+        bandY = endLoc.y;
+    }
+    const actualBandTexHeight = bandY + 1;
+    // Phase 3: Build vertex attributes
+    // 5 attribs x 4 floats x 4 vertices per shape = 80 floats per shape
+    const FLOATS_PER_VERTEX = 20; // 5 attribs * 4 components
+    const VERTS_PER_SHAPE = 4;
+    const vertices = new Float32Array(shapes.length * VERTS_PER_SHAPE * FLOATS_PER_VERTEX);
+    const indices = new Uint16Array(shapes.length * 6);
+    // Corner normals (outward-pointing, un-normalized — SlugDilate normalizes)
+    const cornerNormals = [
+        [-1, -1], // bottom-left
+        [1, -1], // bottom-right
+        [1, 1], // top-right
+        [-1, 1], // top-left
+    ];
+    for (let si = 0; si < shapes.length; si++) {
+        const shape = shapes[si];
+        const sd = shapeBandData[si];
+        const glyph = glyphLocs[si];
+        const [bMinX, bMinY, bMaxX, bMaxY] = shape.bounds;
+        const w = bMaxX - bMinX;
+        const h = bMaxY - bMinY;
+        // Corner positions in object-space
+        const corners = [
+            [bMinX, bMinY],
+            [bMaxX, bMinY],
+            [bMaxX, bMaxY],
+            [bMinX, bMaxY],
+        ];
+        // Em-space sample coords at corners (same as object-space for 1:1 mapping)
+        const emCorners = [
+            [bMinX, bMinY],
+            [bMaxX, bMinY],
+            [bMaxX, bMaxY],
+            [bMinX, bMaxY],
+        ];
+        // Pack tex.z: glyph location in band texture
+        const texZ = uintAsFloat((glyph.x & 0xFFFF) | ((glyph.y & 0xFFFF) << 16));
+        // Pack tex.w: band max + flags
+        let texWBits = (sd.bandMaxX & 0xFF) | ((sd.bandMaxY & 0xFF) << 16);
+        if (evenOdd)
+            texWBits |= 0x10000000; // E flag at bit 28
+        const texW = uintAsFloat(texWBits);
+        // Band transform: scale and offset to map em-coords to band indices
+        const bandScaleX = w > 0 ? sd.vBands.length / w : 0;
+        const bandScaleY = h > 0 ? sd.hBands.length / h : 0;
+        const bandOffsetX = -bMinX * bandScaleX;
+        const bandOffsetY = -bMinY * bandScaleY;
+        for (let vi = 0; vi < 4; vi++) {
+            const base = (si * 4 + vi) * FLOATS_PER_VERTEX;
+            // pos: .xy = position, .zw = normal
+            vertices[base + 0] = corners[vi][0];
+            vertices[base + 1] = corners[vi][1];
+            vertices[base + 2] = cornerNormals[vi][0];
+            vertices[base + 3] = cornerNormals[vi][1];
+            // tex: .xy = em-space coords, .z = packed glyph loc, .w = packed band max
+            vertices[base + 4] = emCorners[vi][0];
+            vertices[base + 5] = emCorners[vi][1];
+            vertices[base + 6] = texZ;
+            vertices[base + 7] = texW;
+            // jac: identity Jacobian (em-space = object-space)
+            vertices[base + 8] = 1.0;
+            vertices[base + 9] = 0.0;
+            vertices[base + 10] = 0.0;
+            vertices[base + 11] = 1.0;
+            // bnd: band scale and offset
+            vertices[base + 12] = bandScaleX;
+            vertices[base + 13] = bandScaleY;
+            vertices[base + 14] = bandOffsetX;
+            vertices[base + 15] = bandOffsetY;
+            // col: white with full alpha (caller overrides via uniform or attribute)
+            vertices[base + 16] = 1.0;
+            vertices[base + 17] = 1.0;
+            vertices[base + 18] = 1.0;
+            vertices[base + 19] = 1.0;
+        }
+        // Indices: two triangles per quad
+        const vBase = si * 4;
+        const iBase = si * 6;
+        indices[iBase + 0] = vBase + 0;
+        indices[iBase + 1] = vBase + 1;
+        indices[iBase + 2] = vBase + 2;
+        indices[iBase + 3] = vBase + 0;
+        indices[iBase + 4] = vBase + 2;
+        indices[iBase + 5] = vBase + 3;
+    }
+    return {
+        curveTexture: {
+            data: curveData.subarray(0, TEX_WIDTH * actualCurveTexHeight * 4),
+            width: TEX_WIDTH,
+            height: actualCurveTexHeight
+        },
+        bandTexture: {
+            data: bandData.subarray(0, TEX_WIDTH * actualBandTexHeight * 4),
+            width: TEX_WIDTH,
+            height: actualBandTexHeight
+        },
+        vertices,
+        indices,
+        shapeCount: shapes.length
+    };
+}
+
+exports.fragmentShaderGLSL300 = fragmentShaderGLSL300;
+exports.fragmentShaderWGSL = fragmentShaderWGSL;
+exports.packSlugData = packSlugData;
+exports.vertexShaderGLSL300 = vertexShaderGLSL300;
+exports.vertexShaderWGSL = vertexShaderWGSL;

package/dist/slug/index.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Pure Slug algorithm types — no dependency on three-text internals.
+ * Based on Eric Lengyel's reference implementation (MIT License, 2017).
+ */
+interface QuadCurve {
+    p1: [number, number];
+    p2: [number, number];
+    p3: [number, number];
+}
+interface SlugShape {
+    curves: QuadCurve[];
+    bounds: [number, number, number, number];
+}
+interface SlugPackedTexture {
+    data: Float32Array | Uint32Array;
+    width: number;
+    height: number;
+}
+interface SlugGPUData {
+    curveTexture: SlugPackedTexture & {
+        data: Float32Array;
+    };
+    bandTexture: SlugPackedTexture & {
+        data: Uint32Array;
+    };
+    /** 5 attribs x 4 components x 4 verts per shape, tightly packed per-shape */
+    vertices: Float32Array;
+    indices: Uint16Array;
+    shapeCount: number;
+}
+interface SlugPackOptions {
+    bandCount?: number;
+    evenOdd?: boolean;
+}
+
+/**
+ * Slug shader source re-exports.
+ * The .glsl/.wgsl files are the single source of truth — imported as strings
+ * at build time via the glslPlugin in rollup.config.js.
+ */
+declare const vertexShaderGLSL300: string;
+declare const fragmentShaderGLSL300: string;
+declare const vertexShaderWGSL: string;
+declare const fragmentShaderWGSL: string;
+
+/**
+ * CPU-side data packer for the Slug algorithm.
+ * Faithful to Eric Lengyel's reference layout (MIT License, 2017).
+ *
+ * Takes generic quadratic Bezier shapes (not text-specific) and produces
+ * GPU-ready packed textures + vertex attribute buffers.
+ */
+
+/**
+ * Pack an array of shapes into Slug's GPU data layout.
+ *
+ * Each shape is a closed region defined by quadratic Bezier curves.
+ * Returns textures + vertex buffers ready for GPU upload.
+ */
+declare function packSlugData(shapes: SlugShape[], options?: SlugPackOptions): SlugGPUData;
+
+export { QuadCurve, SlugGPUData, SlugPackOptions, SlugPackedTexture, SlugShape, fragmentShaderGLSL300, fragmentShaderWGSL, packSlugData, vertexShaderGLSL300, vertexShaderWGSL };