three-text 0.4.11 → 0.5.0

package/dist/p5/index.js

@@ -1,4 +1,2734 @@
 import { Text } from '../index.js';
+import { globalContourCache, globalWordCache, globalClusteringCache, getGlyphCacheKey, globalGlyphCache } from '../index.js';
+import { getSharedDrawCallbackHandler } from '../index.js';
+import { TextLayout } from '../index.js';
+import { TextRangeQuery } from '../index.js';
+
+// 2D Vector
+class Vec2 {
+    constructor(x = 0, y = 0) {
+        this.x = x;
+        this.y = y;
+    }
+    set(x, y) {
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+    clone() {
+        return new Vec2(this.x, this.y);
+    }
+    copy(v) {
+        this.x = v.x;
+        this.y = v.y;
+        return this;
+    }
+    add(v) {
+        this.x += v.x;
+        this.y += v.y;
+        return this;
+    }
+    sub(v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        return this;
+    }
+    multiply(scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+        return this;
+    }
+    divide(scalar) {
+        this.x /= scalar;
+        this.y /= scalar;
+        return this;
+    }
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    }
+    lengthSq() {
+        return this.x * this.x + this.y * this.y;
+    }
+    normalize() {
+        const len = this.length();
+        if (len > 0) {
+            this.divide(len);
+        }
+        return this;
+    }
+    dot(v) {
+        return this.x * v.x + this.y * v.y;
+    }
+    distanceTo(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    distanceToSquared(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        return dx * dx + dy * dy;
+    }
+    equals(v) {
+        return this.x === v.x && this.y === v.y;
+    }
+    angle() {
+        return Math.atan2(this.y, this.x);
+    }
+}
+// 3D Vector
+class Vec3 {
+    constructor(x = 0, y = 0, z = 0) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    set(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+    clone() {
+        return new Vec3(this.x, this.y, this.z);
+    }
+    copy(v) {
+        this.x = v.x;
+        this.y = v.y;
+        this.z = v.z;
+        return this;
+    }
+    add(v) {
+        this.x += v.x;
+        this.y += v.y;
+        this.z += v.z;
+        return this;
+    }
+    sub(v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        this.z -= v.z;
+        return this;
+    }
+    multiply(scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+        this.z *= scalar;
+        return this;
+    }
+    divide(scalar) {
+        this.x /= scalar;
+        this.y /= scalar;
+        this.z /= scalar;
+        return this;
+    }
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    }
+    lengthSq() {
+        return this.x * this.x + this.y * this.y + this.z * this.z;
+    }
+    normalize() {
+        const len = this.length();
+        if (len > 0) {
+            this.divide(len);
+        }
+        return this;
+    }
+    dot(v) {
+        return this.x * v.x + this.y * v.y + this.z * v.z;
+    }
+    cross(v) {
+        const x = this.y * v.z - this.z * v.y;
+        const y = this.z * v.x - this.x * v.z;
+        const z = this.x * v.y - this.y * v.x;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+    distanceTo(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        const dz = this.z - v.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    distanceToSquared(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        const dz = this.z - v.z;
+        return dx * dx + dy * dy + dz * dz;
+    }
+    equals(v) {
+        return this.x === v.x && this.y === v.y && this.z === v.z;
+    }
+}
+
+// Cached flag check at module load time for zero-cost logging
+const isLogEnabled = (() => {
+    if (typeof window !== 'undefined' && window.THREE_TEXT_LOG) {
+        return true;
+    }
+    if (typeof globalThis !== 'undefined' &&
+        globalThis.process?.env?.THREE_TEXT_LOG === 'true') {
+        return true;
+    }
+    return false;
+})();
+class Logger {
+    warn(message, ...args) {
+        console.warn(message, ...args);
+    }
+    error(message, ...args) {
+        console.error(message, ...args);
+    }
+    log(message, ...args) {
+        isLogEnabled && console.log(message, ...args);
+    }
+}
+const logger = new Logger();
+
+class PerformanceLogger {
+    constructor() {
+        this.metrics = [];
+        this.activeTimers = new Map();
+    }
+    start(name, metadata) {
+        // Early exit if disabled - no metric collection
+        if (!isLogEnabled)
+            return;
+        const startTime = performance.now();
+        // Generate unique key for nested timing support
+        const timerKey = `${name}_${startTime}`;
+        this.activeTimers.set(timerKey, startTime);
+        this.metrics.push({
+            name,
+            startTime,
+            metadata
+        });
+    }
+    end(name) {
+        // Early exit if disabled
+        if (!isLogEnabled)
+            return null;
+        const endTime = performance.now();
+        // Find the most recent matching timer by scanning backwards
+        let timerKey;
+        let startTime;
+        for (const [key, time] of Array.from(this.activeTimers.entries()).reverse()) {
+            if (key.startsWith(`${name}_`)) {
+                timerKey = key;
+                startTime = time;
+                break;
+            }
+        }
+        if (startTime === undefined || !timerKey) {
+            logger.warn(`Performance timer "${name}" was not started`);
+            return null;
+        }
+        const duration = endTime - startTime;
+        this.activeTimers.delete(timerKey);
+        // Find the metric in reverse order (most recent first)
+        for (let i = this.metrics.length - 1; i >= 0; i--) {
+            const metric = this.metrics[i];
+            if (metric.name === name &&
+                metric.startTime === startTime &&
+                !metric.endTime) {
+                metric.endTime = endTime;
+                metric.duration = duration;
+                break;
+            }
+        }
+        console.log(`${name}: ${duration.toFixed(2)}ms`);
+        return duration;
+    }
+    getSummary() {
+        if (!isLogEnabled)
+            return {};
+        const summary = {};
+        for (const metric of this.metrics) {
+            if (!metric.duration)
+                continue;
+            const existing = summary[metric.name];
+            if (existing) {
+                existing.count++;
+                existing.totalDuration += metric.duration;
+                existing.avgDuration = existing.totalDuration / existing.count;
+                existing.lastDuration = metric.duration;
+            }
+            else {
+                summary[metric.name] = {
+                    count: 1,
+                    avgDuration: metric.duration,
+                    totalDuration: metric.duration,
+                    lastDuration: metric.duration
+                };
+            }
+        }
+        return summary;
+    }
+    printSummary() {
+        if (!isLogEnabled)
+            return;
+        const summary = this.getSummary();
+        console.table(summary);
+        console.log('Operations:', Object.keys(summary).sort().join(', '));
+    }
+    printBaseline() {
+        if (!isLogEnabled)
+            return;
+        const summary = this.getSummary();
+        Object.entries(summary).forEach(([name, stats]) => {
+            console.log(`BASELINE ${name}: ${stats.avgDuration.toFixed(2)}ms avg (${stats.count} calls)`);
+        });
+    }
+    clear() {
+        if (!isLogEnabled)
+            return;
+        this.metrics.length = 0;
+        this.activeTimers.clear();
+    }
+    time(name, fn, metadata) {
+        if (!isLogEnabled)
+            return fn();
+        this.start(name, metadata);
+        try {
+            return fn();
+        }
+        finally {
+            this.end(name);
+        }
+    }
+    async timeAsync(name, fn, metadata) {
+        if (!isLogEnabled)
+            return fn();
+        this.start(name, metadata);
+        try {
+            return await fn();
+        }
+        finally {
+            this.end(name);
+        }
+    }
+}
+// Create a single instance
+// When debug is disabled, all methods return immediately with minimal overhead
+const perfLogger = new PerformanceLogger();
+
+/**
+ * @license
+ * libtess-ts - TypeScript port of the SGI GLU tessellator
+ * Original Code: OpenGL Sample Implementation, Version 1.2.1,
+ *   released January 26, 2000. Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright 2012, Google Inc. All Rights Reserved.
+ * Copyright 2026, Countertype LLC. All Rights Reserved.
+ * SGI Free Software License B (Version 2.0)
+ * http://oss.sgi.com/projects/FreeB/
+ */
+function t(t,i){return t.s===i.s&&t.t===i.t}function i(t,i){return i.s>t.s||t.s===i.s&&i.t>=t.t}function s(t,i){return i.t>t.t||t.t===i.t&&i.s>=t.s}function e(t){return i(t.h.i,t.i)}function n(t){return i(t.i,t.h.i)}function h(t,i){return Math.abs(t.s-i.s)+Math.abs(t.t-i.t)}function r(t,i,s){let e=i.s-t.s,n=s.s-i.s;return e+n>0?n>e?i.t-t.t+e/(e+n)*(t.t-s.t):i.t-s.t+n/(e+n)*(s.t-t.t):0}function l(t,i,s){let e=i.s-t.s,n=s.s-i.s;return e+n>0?(i.t-s.t)*e+(i.t-t.t)*n:0}function o(t,i,s){let e=i.t-t.t,n=s.t-i.t;return e+n>0?n>e?i.s-t.s+e/(e+n)*(t.s-s.s):i.s-s.s+n/(e+n)*(s.s-t.s):0}function u(t,i,s){let e=i.t-t.t,n=s.t-i.t;return e+n>0?(i.s-s.s)*e+(i.s-t.s)*n:0}function c(t,i,s,e){return (t=0>t?0:t)>(s=0>s?0:s)?e+s/(t+s)*(i-e):0===s?(i+e)/2:i+t/(t+s)*(e-i)}function a(t,s,e){const n=t.event,h=s.l,o=e.l;return h.h.i===n?o.h.i===n?i(h.i,o.i)?0>=l(o.h.i,h.i,o.i):l(h.h.i,o.i,h.i)>=0:0>=l(o.h.i,n,o.i):o.h.i===n?l(h.h.i,n,h.i)>=0:r(h.h.i,n,h.i)>=r(o.h.i,n,o.i)}function f(t){return t.o}function d(t){return t.next}function w(t,i){t.u+=i.u,t.h.u+=i.h.u;}function E(t,i){i.l.N=null,t._.delete(i);}function N(t,i,s){t.A.delete(i.l),i.I=0,i.l=s,s.N=i;}function _(t,i){let s,e=i.l.i;do{i=d(i);}while(i.l.i===e);return i.I&&(s=t.A.connect(f(i).l.h,i.l.O),N(t,i,s),i=d(i)),i}function A(t){let i=t.l.h.i;do{t=d(t);}while(t.l.h.i===i);return t}function I(t,i,s){const e=new Z;return e.l=s,t._.insertBefore(i,e),e.I=0,e.k=0,e.T=0,s.N=e,e}function g(t,i){switch(t.M){case Y.ODD:return !!(1&i);case Y.NONZERO:return 0!==i;case Y.POSITIVE:return i>0;case Y.NEGATIVE:return 0>i;case Y.ABS_GEQ_TWO:return i>=2||-2>=i}throw Error("Invalid winding rule")}function O(t,i){const s=i.l,e=s.D;e.p=i.p,e.L=s,E(t,i);}function k(t,i,s){let e,n=null,h=i,r=i.l;for(;h!==s;){if(h.I=0,n=f(h),e=n.l,e.i!=r.i){if(!n.I){O(t,h);break}e=t.A.connect(r.C.h,e.h),N(t,n,e);}r.C!==e&&(t.A.splice(e.h.O,e),t.A.splice(r,e)),O(t,h),r=n.l,h=n;}return r}function y(t,i,s,e,n,h){let r,l,o,u,c=1;o=s;do{I(t,i,o.h),o=o.C;}while(o!==e);for(null===n&&(n=f(i).l.h.C),l=i,u=n;r=f(l),o=r.l.h,o.i===u.i;)o.C!==u&&(t.A.splice(o.h.O,o),t.A.splice(u.h.O,o)),r.G=l.G-o.u,r.p=g(t,r.G),l.T=1,!c&&D(t,l)&&(w(o,u),E(t,l),t.A.delete(u)),c=0,l=r,u=o;l.T=1,h&&C(t,l);}function T(t,i,s,e,n){i.data=null,t.R&&(rt[0]=i.coords[0],rt[1]=i.coords[1],rt[2]=i.coords[2],i.data=t.R(rt,s,e,t.m)),null===i.data&&(n?(t.v(100156),t.U=1):i.data=s[0]);}function b(t,i,s){t.R&&(ht[0]=i.i.data,ht[1]=s.i.data,ht[2]=null,ht[3]=null,nt[0]=.5,nt[1]=.5,nt[2]=0,nt[3]=0,T(t,i.i,ht,nt,0)),t.A.splice(i,s);}function M(t,i,s,e,n){let r=h(i,t),l=h(s,t),o=.5*l/(r+l),u=.5*r/(r+l);void 0!==e&&void 0!==n&&(e[n]=o,e[n+1]=u),t.coords[0]+=o*i.coords[0]+u*s.coords[0],t.coords[1]+=o*i.coords[1]+u*s.coords[1],t.coords[2]+=o*i.coords[2]+u*s.coords[2];}function D(i,s){let e=f(s);const n=s.l,h=e.l;if(h.i.s>n.i.s||n.i.s===h.i.s&&h.i.t>=n.i.t){if(l(h.h.i,n.i,h.i)>0)return 0;t(n.i,h.i)?n.i!==h.i&&(i.S.delete(n.i.B),b(i,h.h.O,n)):(i.A.V(h.h),i.A.splice(n,h.h.O),s.T=e.T=1);}else {if(0>l(n.h.i,h.i,n.i))return 0;d(s).T=s.T=1,i.A.V(n.h),i.A.splice(h.h.O,n);}return 1}function p(t,i){let s=f(i);const e=i.l,n=s.l;let h;if(n.h.i.s>e.h.i.s||e.h.i.s===n.h.i.s&&n.h.i.t>=e.h.i.t){if(0>l(e.h.i,n.h.i,e.i))return 0;d(i).T=i.T=1,h=t.A.V(e),t.A.splice(n.h,h),h.D.p=i.p;}else {if(l(n.h.i,e.h.i,n.i)>0)return 0;i.T=s.T=1,h=t.A.V(n),t.A.splice(e.O,n.h),h.h.D.p=i.p;}return 1}function L(e,n){let h=f(n),a=n.l,w=h.l;const E=a.i,N=w.i;let I,g,O=a.h.i,b=w.h.i;const p=st||(st=new X);let L,C;if(E===N)return 0;if(I=Math.min(E.t,O.t),g=Math.max(N.t,b.t),I>g)return 0;if(i(E,N)){if(l(b,E,N)>0)return 0}else if(0>l(O,N,E))return 0;return ((t,e,n,h,a)=>{let f,d,w;i(t,e)||(w=t,t=e,e=w),i(n,h)||(w=n,n=h,h=w),i(t,n)||(w=t,t=n,n=w,w=e,e=h,h=w),i(n,e)?i(e,h)?(f=r(t,n,e),d=r(n,e,h),0>f+d&&(f=-f,d=-d),a.s=c(f,n.s,d,e.s)):(f=l(t,n,e),d=-l(t,h,e),0>f+d&&(f=-f,d=-d),a.s=c(f,n.s,d,h.s)):a.s=.5*(n.s+e.s),s(t,e)||(w=t,t=e,e=w),s(n,h)||(w=n,n=h,h=w),s(t,n)||(w=t,t=n,n=w,w=e,e=h,h=w),s(n,e)?s(e,h)?(f=o(t,n,e),d=o(n,e,h),0>f+d&&(f=-f,d=-d),a.t=c(f,n.t,d,e.t)):(f=u(t,n,e),d=-u(t,h,e),0>f+d&&(f=-f,d=-d),a.t=c(f,n.t,d,h.t)):a.t=.5*(n.t+e.t);})(O,E,b,N,p),(e.event.s>p.s||p.s===e.event.s&&e.event.t>=p.t)&&(p.s=e.event.s,p.t=e.event.t),L=N.s>E.s||E.s===N.s&&N.t>=E.t?E:N,(p.s>L.s||L.s===p.s&&p.t>=L.t)&&(p.s=L.s,p.t=L.t),t(p,E)||t(p,N)?(D(e,n),0):!t(O,e.event)&&l(O,e.event,p)>=0||!t(b,e.event)&&0>=l(b,e.event,p)?b===e.event?(e.A.V(a.h),e.A.splice(w.h,a),a=f(n=_(e,n)).l,k(e,f(n),h),y(e,n,a.h.O,a,a,1),1):O===e.event?(e.A.V(w.h),e.A.splice(a.O,w.h.O),h=n,C=f(n=A(n)).l.h.C,h.l=w.h.O,w=k(e,h,null),y(e,n,w.C,a.h.C,C,1),1):(0>l(O,e.event,p)||(d(n).T=n.T=1,e.A.V(a.h),a.i.s=e.event.s,a.i.t=e.event.t),l(b,e.event,p)>0||(n.T=h.T=1,e.A.V(w.h),w.i.s=e.event.s,w.i.t=e.event.t),0):(e.A.V(a.h),e.A.V(w.h),e.A.splice(w.h.O,a),a.i.s=p.s,a.i.t=p.t,a.i.B=e.S.P(a.i),((t,i,s,e,n,h)=>{nt[0]=0,nt[1]=0,nt[2]=0,nt[3]=0,ht[0]=s.data,ht[1]=e.data,ht[2]=n.data,ht[3]=h.data,i.coords[0]=i.coords[1]=i.coords[2]=0,M(i,s,e,nt,0),M(i,n,h,nt,2),T(t,i,ht,nt,1);})(e,a.i,E,O,N,b),d(n).T=n.T=h.T=1,0)}function C(t,i){let s,e,n=f(i);for(;;){for(;n.T;)i=n,n=f(n);if(!i.T&&(n=i,null===(i=d(i))||!i.T))return;if(i.T=0,s=i.l,e=n.l,s.h.i!==e.h.i&&p(t,i)&&(n.I?(E(t,n),t.A.delete(e),n=f(i),e=n.l):i.I&&(E(t,i),t.A.delete(s),s=(i=d(n)).l)),s.i!==e.i)if(s.h.i===e.h.i||i.I||n.I||s.h.i!==t.event&&e.h.i!==t.event)D(t,i);else if(L(t,i))return;s.i===e.i&&s.h.i===e.h.i&&(w(e,s),E(t,i),t.A.delete(s),i=d(n));}}function G(s,n){let h,r,o,u,c,a;const w=et||(et=new Z);w.l=n.L.h,h=s._.search(w),r=f(h),r&&(u=h.l,c=r.l,0!==l(u.h.i,n,u.i)?(o=i(c.h.i,u.h.i)?h:r,h.p||o.I?(a=o===h?s.A.connect(n.L.h,u.O):s.A.connect(c.h.C.h,n.L).h,o.I?N(s,o,a):((t,i)=>{i.G=d(i).G+i.l.u,i.p=g(t,i.G);})(s,I(s,h,a)),R(s,n)):y(s,h,n.L,n.L,null,1)):((i,s,n)=>{let h,r,l,o,u;if(h=s.l,t(h.i,n))b(i,h,n.L);else {if(!t(h.h.i,n))return i.A.V(h.h),s.I&&(i.A.delete(h.C),s.I=0),i.A.splice(n.L,h),void R(i,n);u=f(s=A(s)),l=u.l.h,r=o=l.C,u.I&&(E(i,u),i.A.delete(l),l=r.h.O),i.A.splice(n.L,l),e(r)||(r=null),y(i,s,l.C,o,r,1);}})(s,h,n));}function R(s,e){s.event=e;let n=e.L;for(;null===n.N;)if(n=n.C,n===e.L)return void G(s,e);let h=_(s,n.N),r=f(h);const l=r.l;let o=k(s,r,null);o.C===l?((s,e,n)=>{let h,r=n.C,l=f(e),o=e.l,u=l.l,c=0;o.h.i!==u.h.i&&L(s,e),t(o.i,s.event)&&(s.A.splice(r.h.O,o),r=f(e=_(s,e)).l,k(s,f(e),l),c=1),t(u.i,s.event)&&(s.A.splice(n,u.h.O),n=k(s,l,null),c=1),c?y(s,e,n.C,r,r,1):(h=i(u.i,o.i)?u.h.O:o,h=s.A.connect(n.C.h,h),y(s,e,h,h.C,h.C,0),h.h.N.I=1,C(s,e));})(s,h,o):y(s,h,o.C,l,l,1);}function m(t,i,s,e){const n=new Z;let h=t.A.F();h.i.s=s,h.i.t=e,h.h.i.s=i,h.h.i.t=e,t.event=h.h.i,n.l=h,n.G=0,n.p=0,n.I=0,n.k=1,n.T=0,t._.P(n);}function v(t,i){const s=t.Y;let e=s.next,n=e.coords[0],h=e.coords[1],r=e.coords[2],l=n,o=h,u=r,c=e,a=e,f=e,d=e,w=e,E=e;for(e=s.next;e!==s;e=e.next){const t=e.coords[0],i=e.coords[1],s=e.coords[2];n>t&&(n=t,c=e),t>l&&(l=t,d=e),h>i&&(h=i,a=e),i>o&&(o=i,w=e),r>s&&(r=s,f=e),s>u&&(u=s,E=e);}let N=0,_=l-n;const A=o-h;let I,g;if(A>_&&(N=1,_=A),u-r>_&&(N=2),0===N){if(n>=l)return i[0]=0,i[1]=0,void(i[2]=1);I=c,g=d;}else if(1===N){if(h>=o)return i[0]=0,i[1]=0,void(i[2]=1);I=a,g=w;}else {if(r>=u)return i[0]=0,i[1]=0,void(i[2]=1);I=f,g=E;}const O=I.coords[0]-g.coords[0],k=I.coords[1]-g.coords[1],y=I.coords[2]-g.coords[2];let T=0;for(e=s.next;e!==s;e=e.next){const t=e.coords[0]-g.coords[0],s=e.coords[1]-g.coords[1],n=e.coords[2]-g.coords[2],h=k*n-y*s,r=y*t-O*n,l=O*s-k*t,o=h*h+r*r+l*l;o>T&&(T=o,i[0]=h,i[1]=r,i[2]=l);}T>0||(i[0]=i[1]=i[2]=0,Math.abs(k)>Math.abs(O)?i[Math.abs(y)>Math.abs(k)?2:1]=1:i[Math.abs(y)>Math.abs(O)?2:0]=1);}function x(t,i){let s,e,n,h=t.j,r=t.Y,l=0;for(s=h.next;s!==h;s=s.next)if(n=s.L,n.u>0)do{l+=(n.i.s-n.h.i.s)*(n.i.t+n.h.i.t),n=n.O;}while(n!==s.L);if(0>l){for(e=r.next;e!==r;e=e.next)e.t=-e.t;i[0]=-i[0],i[1]=-i[1],i[2]=-i[2];}}function U(t,i){let s=0;for(let e=i.j.next;e!==i.j;e=e.next)e.p&&(s||(t.H(4),s=1),B(e,t));s&&t.q();}function S(t,i,s,e){0>i.s*(s.t-e.t)+s.s*(e.t-i.t)+e.s*(i.t-s.t)?(t.W(i.data),t.W(e.data),t.W(s.data)):(t.W(i.data),t.W(s.data),t.W(e.data));}function B(t,s){let e=0,n=t.L;do{ot[e++]=n.i,n=n.O;}while(n!==t.L);if(3>e)return;if(3===e)return void S(s,ot[0],ot[1],ot[2]);(t=>{if(t>ut.length){const i=2*t;ut=new Int8Array(i),ct=new Int32Array(i),at=new Int32Array(i);}})(e);let h=0,r=0;for(let t=1;e>t;t++)i(ot[t],ot[h])||(h=t),i(ot[t],ot[r])&&(r=t);if(h===r)return;let l=0;ct[l]=h,ut[l]=1,l++;let o=(h+1)%e,u=(h+e-1)%e;for(;o!==r||u!==r;){let t;t=o===r?0:u===r?1:!i(ot[o],ot[u]),t?(ct[l]=o,ut[l]=1,l++,o=(o+1)%e):(ct[l]=u,ut[l]=0,l++,u=(u+e-1)%e);}ct[l]=r,ut[l]=1,l++;let c=0;at[c++]=0,at[c++]=1;for(let t=2;l-1>t;t++)if(ut[t]!==ut[at[c-1]]){for(;c>1;){const i=at[--c];S(s,ot[ct[t]],ot[ct[i]],ot[ct[at[c-1]]]);}--c,at[c++]=t-1,at[c++]=t;}else {let i=at[--c];for(;c>0;){const e=ot[ct[t]],n=ot[ct[i]],h=ot[ct[at[c-1]]],r=e.s*(n.t-h.t)+n.s*(h.t-e.t)+h.s*(e.t-n.t);if(!(1===ut[t]?0>=r:r>=0))break;S(s,e,n,h),i=at[--c];}at[c++]=i,at[c++]=t;}for(;c>1;){const t=at[--c];S(s,ot[ct[l-1]],ot[ct[t]],ot[ct[at[c-1]]]);}}function V(t,i){let s;for(let e=t.Z.next;e!==t.Z;e=s)s=e.next,e.h.D.p!==e.D.p?e.u=e.D.p?i:-i:t.delete(e);}function P(t,i){let s=0,e=-1;for(let n=i.j.o;n!==i.j;n=n.o){if(!n.p)continue;s||(t.H(4),s=1);let i=n.L;do{{const s=i.h&&i.h.D&&i.h.D.p?0:1;e!==s&&(e=s,t.K(!!e));}t.W(i.i.data),i=i.O;}while(i!==n.L)}s&&t.q();}function F(t,i){for(let s=i.j.next;s!==i.j;s=s.next){if(!s.p)continue;t.H(2);let i=s.L;do{t.W(i.i.data),i=i.O;}while(i!==s.L);t.q();}}var Y,j,H,z;(t=>{t[t.ODD=0]="ODD",t[t.NONZERO=1]="NONZERO",t[t.POSITIVE=2]="POSITIVE",t[t.NEGATIVE=3]="NEGATIVE",t[t.ABS_GEQ_TWO=4]="ABS_GEQ_TWO";})(Y||(Y={})),(t=>{t[t.X=0]="POLYGONS",t[t.J=1]="CONNECTED_POLYGONS",t[t.$=2]="BOUNDARY_CONTOURS";})(j||(j={})),(t=>{t[t.BEGIN=100100]="BEGIN",t[t.EDGE_FLAG=100104]="EDGE_FLAG",t[t.VERTEX=100101]="VERTEX",t[t.END=100102]="END",t[t.ERROR=100103]="ERROR",t[t.COMBINE=100105]="COMBINE",t[t.BEGIN_DATA=100106]="BEGIN_DATA",t[t.EDGE_FLAG_DATA=100110]="EDGE_FLAG_DATA",t[t.VERTEX_DATA=100107]="VERTEX_DATA",t[t.END_DATA=100108]="END_DATA",t[t.ERROR_DATA=100109]="ERROR_DATA",t[t.COMBINE_DATA=100111]="COMBINE_DATA",t[t.WINDING_RULE=100140]="WINDING_RULE",t[t.BOUNDARY_ONLY=100141]="BOUNDARY_ONLY",t[t.TOLERANCE=100142]="TOLERANCE";})(H||(H={})),(t=>{t[t.tt=100151]="MISSING_BEGIN_POLYGON",t[t.it=100152]="MISSING_BEGIN_CONTOUR",t[t.st=100153]="MISSING_END_POLYGON",t[t.et=100154]="MISSING_END_CONTOUR",t[t.nt=100155]="COORD_TOO_LARGE",t[t.ht=100156]="NEED_COMBINE_CALLBACK";})(z||(z={}));class Z{next;o;l=null;G=0;p=0;k=0;T=0;I=0}class K{next;i;h;C;O;D;N=null;u=0}class X{next;o;L;coords=[0,0,0];s=0;t=0;B=0;data=null}class Q{next;o;L;p=0}class J{Y;j;Z;rt;vertexCount=0;constructor(){const t=new X,i=new Q,s=new K,e=new K;t.next=t.o=t,i.next=i.o=i,s.next=s,s.h=e,e.next=e,e.h=s,this.Y=t,this.j=i,this.Z=s,this.rt=e;}lt(t){const i=new K,s=new K,e=t.h.next;return s.next=e,e.h.next=i,i.next=t,t.h.next=s,i.h=s,i.C=i,i.O=s,i.u=0,i.N=null,s.h=i,s.C=s,s.O=i,s.u=0,s.N=null,i}ot(t,i){const s=t.C,e=i.C;s.h.O=i,e.h.O=t,t.C=e,i.C=s;}ut(t,i,s){const e=t,n=s.o;e.o=n,n.next=e,e.next=s,s.o=e,e.L=i,++this.vertexCount;let h=i;do{h.i=e,h=h.C;}while(h!==i)}ct(t,i,s){const e=t,n=s.o;e.o=n,n.next=e,e.next=s,s.o=e,e.L=i,e.p=s.p;let h=i;do{h.D=e,h=h.O;}while(h!==i)}ft(t){const i=t.next,s=t.h.next;i.h.next=s,s.h.next=i;}dt(t,i){const s=t.L;let e=s;do{e.i=i,e=e.C;}while(e!==s);const n=t.o,h=t.next;h.o=n,n.next=h,--this.vertexCount;}wt(t,i){const s=t.L;let e=s;do{e.D=i,e=e.O;}while(e!==s);const n=t.o,h=t.next;h.o=n,n.next=h;}F(){const t=new X,i=new X,s=new Q,e=this.lt(this.Z);return this.ut(t,e,this.Y),this.ut(i,e.h,this.Y),this.ct(s,e,this.j),e}splice(t,i){let s=0,e=0;if(t!==i){if(i.i!==t.i&&(e=1,this.dt(i.i,t.i)),i.D!==t.D&&(s=1,this.wt(i.D,t.D)),this.ot(i,t),!e){const s=new X;this.ut(s,i,t.i),t.i.L=t;}if(!s){const s=new Q;this.ct(s,i,t.D),t.D.L=t;}}}delete(t){const i=t.h;let s=0;if(t.D!==t.h.D&&(s=1,this.wt(t.D,t.h.D)),t.C===t)this.dt(t.i,null);else if(t.h.D.L=t.h.O,t.i.L=t.C,this.ot(t,t.h.O),!s){const i=new Q;this.ct(i,t,t.D);}i.C===i?(this.dt(i.i,null),this.wt(i.D,null)):(t.D.L=i.h.O,i.i.L=i.C,this.ot(i,i.h.O)),this.ft(t);}Et(t){const i=this.lt(t),s=i.h;this.ot(i,t.O),i.i=t.h.i;const e=new X;return this.ut(e,s,i.i),i.D=s.D=t.D,i}V(t){const i=this.Et(t).h;return this.ot(t.h,t.h.h.O),this.ot(t.h,i),t.h.i=i.i,i.h.i.L=i.h,i.h.D=t.h.D,i.u=t.u,i.h.u=t.h.u,i}connect(t,i){let s=0;const e=this.lt(t),n=e.h;if(i.D!==t.D&&(s=1,this.wt(i.D,t.D)),this.ot(e,t.O),this.ot(n,i),e.i=t.h.i,n.i=i.i,e.D=n.D=t.D,t.D.L=n,!s){const i=new Q;this.ct(i,e,t.D);}return e}Nt(t){const i=t.L;let s,e,n,h,r;e=i.O;do{s=e,e=s.O,s.D=null,s.h.D||(s.C===s?this.dt(s.i,null):(s.i.L=s.C,this.ot(s,s.h.O)),n=s.h,n.C===n?this.dt(n.i,null):(n.i.L=n.C,this.ot(n,n.h.O)),this.ft(s));}while(s!=i);h=t.o,r=t.next,r.o=h,h.next=r;}_t(t){let i=t.L,s=0;do{s++,i=i.O;}while(i!==t.L);return s}check(){}}class ${max=0;At;It;gt;Ot=0;kt=0;size=0;constructor(t){this.max=t,this.At=new Int32Array(t+1),this.It=Array(t+1).fill(null),this.gt=new Int32Array(t+1),this.Ot=0,this.At[1]=1,this.It[1]=null;}reset(t){if(t+1>this.max)this.max=t,this.At=new Int32Array(t+1),this.It=Array(t+1).fill(null),this.gt=new Int32Array(t+1);else {const t=this.It;for(let i=1;this.size>=i;i++)t[i]=null;}this.size=0,this.kt=0,this.Ot=0,this.At[1]=1,this.It[1]=null;}yt(t){const i=this.At,s=this.It,e=this.gt;let n=i[t];for(;;){let h=t<<1;if(h>this.size)break;let r=h,l=i[h];if(this.size>=h+1){const t=i[h+1],e=s[t],n=s[l];(n.s>e.s||e.s===n.s&&n.t>=e.t)&&(r=h+1,l=t);}const o=s[n],u=s[l];if(u.s>o.s||o.s===u.s&&u.t>=o.t)break;i[t]=l,e[l]=t,t=r;}i[t]=n,e[n]=t;}Tt(t){const i=this.At,s=this.It,e=this.gt;let n=i[t];for(;;){const h=t>>1;if(0===h)break;const r=i[h],l=s[r],o=s[n];if(o.s>l.s||l.s===o.s&&o.t>=l.t)break;i[t]=r,e[r]=t,t=h;}i[t]=n,e[n]=t;}init(){for(let t=this.size>>1;t>=1;--t)this.yt(t);this.Ot=1;}bt(){return 0===this.size}min(){return 0===this.size?null:this.It[this.At[1]]}P(t){let i,s;if(i=++this.size,2*i>this.max){this.max*=2;const t=new Int32Array(this.max+1),i=new Int32Array(this.max+1),s=Array(this.max+1).fill(null);t.set(this.At),i.set(this.gt);for(let t=0;this.It.length>t;t++)s[t]=this.It[t];this.At=t,this.gt=i,this.It=s;}return 0===this.kt?s=i:(s=this.kt,this.kt=this.gt[s]),this.At[i]=s,this.gt[s]=i,this.It[s]=t,this.Ot&&this.Tt(i),s}Mt(){const t=this.At,i=this.It,s=this.gt;let e=t[1],n=i[e];return this.size>0&&(t[1]=t[this.size],s[t[1]]=1,i[e]=null,s[e]=this.kt,this.kt=e,--this.size,this.size>0&&this.yt(1)),n}delete(t){const i=this.At,s=this.It,e=this.gt;let n;if(n=e[t],i[n]=i[this.size],e[i[n]]=n,--this.size,this.size>=n)if(n>1){const t=s[i[n>>1]],e=s[i[n]];e.s>t.s||t.s===e.s&&e.t>=t.t?this.yt(n):this.Tt(n);}else this.yt(n);s[t]=null,e[t]=this.kt,this.kt=t;}}class tt{Dt;keys;order=null;size=0;max=0;Ot=0;Lt;constructor(t){this.max=t,this.size=0,this.Ot=0,this.Lt=128>=t,this.Dt=new $(t),this.Lt||(this.keys=Array(t).fill(null));}reset(t){this.Dt.reset(t),this.Lt=128>=t,this.Lt||this.keys&&this.max>=t||(this.keys=Array(t).fill(null)),t>this.max&&(this.max=t),this.size=0,this.Ot=0,this.order=null;}P(t){if(this.Lt||this.Ot)return this.Dt.P(t);const i=this.size;if(++this.size>=this.max){const t=this.max;this.max*=2;const i=Array(this.max).fill(null);for(let s=0;t>s;s++)i[s]=this.keys[s];this.keys=i;}return this.keys[i]=t,-(i+1)}init(){if(this.Lt)return this.Ot=1,this.Dt.init(),1;this.order=Array(this.size);for(let t=0;this.size>t;t++)this.order[t]=t;const t=this.keys;return this.order.sort((i,s)=>{const e=t[i],n=t[s];return n.s>e.s?1:e.s>n.s||e.t>n.t?-1:1}),this.max=this.size,this.Ot=1,this.Dt.init(),1}Mt(){if(this.Lt||0===this.size)return this.Dt.Mt();const t=this.keys[this.order[this.size-1]];if(!this.Dt.bt()){const s=this.Dt.min();if(s&&i(s,t))return this.Dt.Mt()}do{--this.size;}while(this.size>0&&null===this.keys[this.order[this.size-1]]);return t}min(){if(this.Lt||0===this.size)return this.Dt.min();const t=this.keys[this.order[this.size-1]];if(!this.Dt.bt()){const s=this.Dt.min();if(s&&i(s,t))return s}return t}delete(t){0>t?this.keys[-(t+1)]=null:this.Dt.delete(t);}bt(){return (this.Lt||0===this.size)&&this.Dt.bt()}}class it{head=new Z;frame;constructor(t){this.frame=t,this.head.next=this.head,this.head.o=this.head;}min(){return this.head.next}max(){return this.head.o}P(t){return this.insertBefore(this.head,t)}search(t){let i=this.head;do{i=i.next;}while(null!==i.l&&!a(this.frame,t,i));return i}insertBefore(t,i){do{t=t.o;}while(null!==t.l&&!a(this.frame,t,i));return i.next=t.next,t.next.o=i,i.o=t,t.next=i,i}delete(t){t.next.o=t.o,t.o.next=t.next;}}let st=null,et=null;const nt=[0,0,0,0],ht=[null,null,null,null],rt=[0,0,0];class lt{static Ct(t,i){t.u+=i.u,t.h.u+=i.h.u;}static Gt(t,s){let h,r,o;if(h=s.L,h.O===h||h.O.O===h)throw Error("Monotone region has degenerate topology");for(;i(h.h.i,h.i);h=h.C.h);for(;i(h.i,h.h.i);h=h.O);for(r=h.C.h;h.O!==r;)if(i(h.h.i,r.i)){for(;r.O!==h&&(e(r.O)||0>=l(r.i,r.h.i,r.O.h.i));)o=t.connect(r.O,r),r=o.h;r=r.C.h;}else {for(;r.O!==h&&(n(h.C.h)||l(h.h.i,h.i,h.C.h.i)>=0);)o=t.connect(h,h.C.h),h=o.h;h=h.O;}if(r.O===h)throw Error("Monotone region has insufficient vertices");for(;r.O.O!==h;)o=t.connect(r.O,r),r=o.h;return 1}static tessellateInterior(t){let i;for(let s=t.j.next;s!==t.j;s=i)i=s.next,s.p&&lt.Gt(t,s);return 1}}let ot=[],ut=new Int8Array(64),ct=new Int32Array(64),at=new Int32Array(64);var ft;(t=>{t[t.Rt=0]="T_DORMANT",t[t.vt=1]="T_IN_POLYGON",t[t.xt=2]="T_IN_CONTOUR";})(ft||(ft={}));class dt{state=ft.Rt;Ut=null;St=0;Bt=0;Vt=1;Pt=0;Ft=0;Yt=0;jt=0;A;Ht=[0,0,0];zt;qt;Wt;Zt;M=Y.ODD;Kt=Y.ODD;_;S;event;Xt;Qt;Jt;$t;ti;ii;R;si;m=null;U=0;gluTessCallback(t,i){const s=i||null;switch(t){case 100100:case 100106:this.Xt=s;break;case 100104:case 100110:this.$t=s,this.flagBoundary=1;break;case 100101:case 100107:this.Qt=s;break;case 100102:case 100108:this.Jt=s;break;case 100103:this.ti=s;break;case 100109:this.ii=s;break;case 100105:case 100111:this.R=s;break;case 100112:this.si=s;break;default:throw Error("GLU_INVALID_ENUM")}}gluTessProperty(t,i){switch(t){case 100140:{const t=i,s=100130>t?t:t-100130;if(0>s||s>4)throw Error("GLU_INVALID_VALUE");this.Kt=t,this.M=s;break}case 100141:this.ei=!!i;break;case 100142:break;default:throw Error("GLU_INVALID_ENUM")}}gluGetTessProperty(t){switch(t){case 100140:return this.Kt;case 100141:return this.ei;case 100142:return 0;default:throw Error("GLU_INVALID_ENUM")}}gluTessNormal(t,i,s){this.Ht[0]=t,this.Ht[1]=i,this.Ht[2]=s,0===s||t||i||(this.Vt=s>0?1:-1);}H(t){this.Xt&&this.Xt(t,this.m);}W(t){this.Qt&&this.Qt(t,this.m);}q(){this.Jt&&this.Jt(this.m);}K(t){this.$t&&this.$t(t,this.m);}v(t){this.ii?this.ii(t,this.m):this.ti&&this.ti(t);}ni(t){if(this.state!==t)for(;this.state!==t;)t>this.state?this.state===ft.Rt?(this.v(100151),this.gluTessBeginPolygon()):this.state===ft.vt&&(this.v(100152),this.gluTessBeginContour()):this.state===ft.xt?(this.v(100154),this.gluTessEndContour()):this.state===ft.vt&&(this.v(100153),this.gluTessEndPolygon());}ei=0;flagBoundary=0;hi(){const t=this.A,i=t.Y,s=this.Ht[0],e=this.Ht[1],n=this.Ht[2];let h,r;if(this.zt||(this.zt=[0,0,0]),this.qt||(this.qt=[0,0,0]),this.Wt||(this.Wt=[0,0]),this.Zt||(this.Zt=[0,0]),h=this.zt,r=this.qt,this.Bt){h[0]=1,h[1]=0,h[2]=0;const t=n>0?1:-1;return r[0]=0,r[1]=t,r[2]=0,this.Wt[0]=this.Pt,this.Wt[1]=this.Yt,this.Zt[0]=this.Ft,void(this.Zt[1]=this.jt)}if(!this.St&&!s&&!e){let s;h[0]=1,h[1]=0,h[2]=0;let e=0;if(n)s=n>0?1:-1;else {const i=[0,0,0];v(t,i),s=i[2]>0?1:-1,e=1;}r[0]=0,r[1]=s,r[2]=0;let l=i.next,o=l.coords[0],u=l.coords[1]*s;l.s=o,l.t=u;let c=o,a=o,f=u,d=u;for(l=l.next;l!==i;l=l.next)o=l.coords[0],u=l.coords[1]*s,l.s=o,l.t=u,c>o?c=o:o>a&&(a=o),f>u?f=u:u>d&&(d=u);return this.Wt[0]=c,this.Zt[0]=a,void(e?(x(t,this.qt),r[1]!==s?(this.Wt[1]=-d,this.Zt[1]=-f):(this.Wt[1]=f,this.Zt[1]=d)):(this.Wt[1]=f,this.Zt[1]=d))}let l=0;const o=[s,e,n];s||e||n||(v(t,o),l=1);const u=(t=>{let i=0;return Math.abs(t[1])>Math.abs(t[0])&&(i=1),Math.abs(t[2])>Math.abs(t[i])&&(i=2),i})(o);h[u]=0,h[(u+1)%3]=1,h[(u+2)%3]=0,r[u]=0,r[(u+1)%3]=0,r[(u+2)%3]=o[u]>0?1:-1;let c=i.next;c.s=c.coords[0]*h[0]+c.coords[1]*h[1]+c.coords[2]*h[2],c.t=c.coords[0]*r[0]+c.coords[1]*r[1]+c.coords[2]*r[2];let a=c.s,f=c.s,d=c.t,w=c.t;for(c=c.next;c!==i;c=c.next){const t=c.coords[0]*h[0]+c.coords[1]*h[1]+c.coords[2]*h[2],i=c.coords[0]*r[0]+c.coords[1]*r[1]+c.coords[2]*r[2];c.s=t,c.t=i,a>t?a=t:t>f&&(f=t),d>i?d=i:i>w&&(w=i);}l&&x(t,this.qt),l&&r[(u+2)%3]!==(o[u]>0?1:-1)?(this.Wt[0]=a,this.Zt[0]=f,this.Wt[1]=-w,this.Zt[1]=-d):(this.Wt[0]=a,this.Zt[0]=f,this.Wt[1]=d,this.Zt[1]=w);}gluTessBeginPolygon(t){this.ni(ft.Rt),this.state=ft.vt,this.U=0,this.A=new J,this.St=0,this.Bt=0!==this.Ht[2]&&!this.Ht[0]&&!this.Ht[1],this.Pt=1/0,this.Ft=-1/0,this.Yt=1/0,this.jt=-1/0,this.m=t;}gluTessBeginContour(){this.ni(ft.vt),this.state=ft.xt,this.Ut=null;}gluTessVertex(t,i){this.ni(ft.xt);let s=t[0],e=t[1],n=t.length>2?t[2]:0,h=0;-1e150>s?(s=-1e150,h=1):s>1e150&&(s=1e150,h=1),-1e150>e?(e=-1e150,h=1):e>1e150&&(e=1e150,h=1),-1e150>n?(n=-1e150,h=1):n>1e150&&(n=1e150,h=1),h&&this.v(100155);let r=this.Ut;if(null===r?(r=this.A.F(),this.A.splice(r,r.h)):(this.A.V(r),r=r.O),r.i.data=i||null,r.i.coords[0]=s,r.i.coords[1]=e,0!==n?(r.i.coords[2]=n,this.St=1,this.Bt=0):r.i.coords[2]=0,this.Bt){r.i.s=s;const t=e*this.Vt;r.i.t=t,this.Pt>s&&(this.Pt=s),s>this.Ft&&(this.Ft=s),this.Yt>t&&(this.Yt=t),t>this.jt&&(this.jt=t);}r.u=1,r.h.u=-1,this.Ut=r;}gluTessEndContour(){this.ni(ft.xt),this.state=ft.vt;}gluTessEndPolygon(){this.ni(ft.vt),this.state=ft.Rt,this.compute(this.M,void 0,0);const t=this.A;this.U||(this.ei?(V(t,1),F(this,t)):this.flagBoundary?(lt.tessellateInterior(t),P(this,t)):U(this,t)),this.si&&this.si(t),this.A=null,this.Ut=null,this.event=null,this.m=null,this._=null;}gluDeleteTess(){this.ni(ft.Rt);}compute(i=Y.ODD,s,e=0){this.state!==ft.Rt&&this.state===ft.vt&&(this.state=ft.Rt),this.A||(this.A=new J),s&&(this.Ht[0]=s[0],this.Ht[1]=s[1],this.Ht[2]=s[2]),this.M=i,this.hi(),function(i,s=1){let e,n;if((i=>{let s,e,n,h=i.A.Z;for(s=h.next;s!==h;s=e)e=s.next,n=s.O,t(s.i,s.h.i)&&s.O.O!==s&&(b(i,n,s),i.A.delete(s),s=n,n=s.O),n.O===s&&(n!==s&&(n!==e&&n!==e.h||(e=e.next),i.A.delete(n)),s!==e&&s!==e.h||(e=e.next),i.A.delete(s));})(i),!(t=>{let i,s,e,n=t.A.vertexCount+8;for(t.S?(t.S.reset(n),i=t.S):i=t.S=new tt(n),e=t.A.Y,s=e.next;s!==e;s=s.next)s.B=i.P(s);return s!==e?0:(i.init(),1)})(i))return 0;for((t=>{t._=new it(t);let i=t.Zt[0]-t.Wt[0],s=t.Zt[1]-t.Wt[1],e=t.Wt[0]-i,n=t.Zt[0]+i,h=t.Zt[1]+s;m(t,e,n,t.Wt[1]-s),m(t,e,n,h);})(i);null!==(e=i.S.Mt());){for(;n=i.S.min(),null!==n&&t(n,e);)n=i.S.Mt(),b(i,e.L,n.L);R(i,e);}i.event=i._.min().l.i,(t=>{let i;for(;null!==(i=t._.min()).l;)E(t,i);})(i),((t,i)=>{let s,e,n;for(s=i.j.next;s!==i.j;s=e)e=s.next,n=s.L,n.O.O===n&&(w(n.C,n),t.A.delete(n));})(i,i.A),s&&i.A.check();}(this,e);}renderBoundary(){this.A&&(V(this.A,1),F(this,this.A));}renderTriangles(t=0){this.A&&(t?(lt.tessellateInterior(this.A),P(this,this.A)):U(this,this.A));}}
+
+class Tessellator {
+    process(paths, removeOverlaps = true, isCFF = false, needsExtrusionContours = true) {
+        if (paths.length === 0) {
+            return { triangles: { vertices: [], indices: [] }, contours: [] };
+        }
+        const valid = paths.filter((path) => path.points.length >= 3);
+        if (valid.length === 0) {
+            return { triangles: { vertices: [], indices: [] }, contours: [] };
+        }
+        logger.log(`Tessellator: removeOverlaps=${removeOverlaps}, processing ${valid.length} paths`);
+        return this.tessellate(valid, removeOverlaps, isCFF, needsExtrusionContours);
+    }
+    processContours(contours, removeOverlaps = true, isCFF = false, needsExtrusionContours = true) {
+        if (contours.length === 0) {
+            return { triangles: { vertices: [], indices: [] }, contours: [] };
+        }
+        return this.tessellateContours(contours, removeOverlaps, isCFF, needsExtrusionContours);
+    }
+    tessellate(paths, removeOverlaps, isCFF, needsExtrusionContours) {
+        // libtess expects CCW winding; TTF outer contours are CW
+        const needsWindingReversal = !isCFF && !removeOverlaps;
+        let originalContours;
+        let tessContours;
+        if (needsWindingReversal) {
+            tessContours = this.pathsToContours(paths, true);
+            if (removeOverlaps || needsExtrusionContours) {
+                originalContours = this.pathsToContours(paths);
+            }
+        }
+        else {
+            originalContours = this.pathsToContours(paths);
+            tessContours = originalContours;
+        }
+        let extrusionContours = needsExtrusionContours
+            ? needsWindingReversal
+                ? tessContours
+                : (originalContours ?? this.pathsToContours(paths))
+            : [];
+        if (removeOverlaps) {
+            logger.log('Two-pass: boundary extraction then triangulation');
+            perfLogger.start('Tessellator.boundaryPass', {
+                contourCount: tessContours.length
+            });
+            const boundaryResult = this.performTessellation(originalContours, 'boundary');
+            perfLogger.end('Tessellator.boundaryPass');
+            if (!boundaryResult) {
+                logger.warn('libtess returned empty result from boundary pass');
+                return { triangles: { vertices: [], indices: [] }, contours: [] };
+            }
+            // Boundary pass normalizes winding (outer CCW, holes CW)
+            tessContours = this.boundaryToContours(boundaryResult);
+            if (needsExtrusionContours) {
+                extrusionContours = tessContours;
+            }
+            logger.log(`Boundary pass created ${tessContours.length} contours. Starting triangulation pass.`);
+        }
+        else {
+            logger.log(`Single-pass triangulation for ${isCFF ? 'CFF' : 'TTF'}`);
+        }
+        perfLogger.start('Tessellator.triangulationPass', {
+            contourCount: tessContours.length
+        });
+        const triangleResult = this.performTessellation(tessContours, 'triangles');
+        perfLogger.end('Tessellator.triangulationPass');
+        if (!triangleResult) {
+            const warning = removeOverlaps
+                ? 'libtess returned empty result from triangulation pass'
+                : 'libtess returned empty result from single-pass triangulation';
+            logger.warn(warning);
+            return {
+                triangles: { vertices: [], indices: [] },
+                contours: extrusionContours
+            };
+        }
+        return {
+            triangles: {
+                vertices: triangleResult.vertices,
+                indices: triangleResult.indices || []
+            },
+            contours: extrusionContours,
+            contoursAreBoundary: removeOverlaps
+        };
+    }
+    tessellateContours(contours, removeOverlaps, isCFF, needsExtrusionContours) {
+        const needsWindingReversal = !isCFF && !removeOverlaps;
+        let originalContours;
+        let tessContours;
+        if (needsWindingReversal) {
+            tessContours = this.reverseContours(contours);
+            if (removeOverlaps || needsExtrusionContours) {
+                originalContours = contours;
+            }
+        }
+        else {
+            originalContours = contours;
+            tessContours = contours;
+        }
+        let extrusionContours = needsExtrusionContours
+            ? needsWindingReversal
+                ? tessContours
+                : (originalContours ?? contours)
+            : [];
+        if (removeOverlaps) {
+            logger.log('Two-pass: boundary extraction then triangulation');
+            perfLogger.start('Tessellator.boundaryPass', {
+                contourCount: tessContours.length
+            });
+            const boundaryResult = this.performTessellation(originalContours, 'boundary');
+            perfLogger.end('Tessellator.boundaryPass');
+            if (!boundaryResult) {
+                logger.warn('libtess returned empty result from boundary pass');
+                return { triangles: { vertices: [], indices: [] }, contours: [] };
+            }
+            tessContours = this.boundaryToContours(boundaryResult);
+            if (needsExtrusionContours) {
+                extrusionContours = tessContours;
+            }
+            logger.log(`Boundary pass created ${tessContours.length} contours. Starting triangulation pass.`);
+        }
+        else {
+            logger.log(`Single-pass triangulation for ${isCFF ? 'CFF' : 'TTF'}`);
+        }
+        perfLogger.start('Tessellator.triangulationPass', {
+            contourCount: tessContours.length
+        });
+        const triangleResult = this.performTessellation(tessContours, 'triangles');
+        perfLogger.end('Tessellator.triangulationPass');
+        if (!triangleResult) {
+            const warning = removeOverlaps
+                ? 'libtess returned empty result from triangulation pass'
+                : 'libtess returned empty result from single-pass triangulation';
+            logger.warn(warning);
+            return {
+                triangles: { vertices: [], indices: [] },
+                contours: extrusionContours
+            };
+        }
+        return {
+            triangles: {
+                vertices: triangleResult.vertices,
+                indices: triangleResult.indices || []
+            },
+            contours: extrusionContours,
+            contoursAreBoundary: removeOverlaps
+        };
+    }
+    pathsToContours(paths, reversePoints = false) {
+        const contours = new Array(paths.length);
+        for (let p = 0; p < paths.length; p++) {
+            const points = paths[p].points;
+            const pointCount = points.length;
+            // Clipper-style paths can be explicitly closed by repeating the first point at the end
+            // Normalize to a single closing vertex for stable side wall generation
+            const isClosed = pointCount > 1 &&
+                points[0].x === points[pointCount - 1].x &&
+                points[0].y === points[pointCount - 1].y;
+            const end = isClosed ? pointCount - 1 : pointCount;
+            // +1 to append a closing vertex
+            const contour = new Array((end + 1) * 2);
+            let i = 0;
+            if (reversePoints) {
+                for (let k = end - 1; k >= 0; k--) {
+                    const pt = points[k];
+                    contour[i++] = pt.x;
+                    contour[i++] = pt.y;
+                }
+            }
+            else {
+                for (let k = 0; k < end; k++) {
+                    const pt = points[k];
+                    contour[i++] = pt.x;
+                    contour[i++] = pt.y;
+                }
+            }
+            // Some glyphs omit closePath, leaving gaps in extruded side walls
+            if (i >= 2) {
+                contour[i++] = contour[0];
+                contour[i++] = contour[1];
+            }
+            contours[p] = contour;
+        }
+        return contours;
+    }
+    reverseContours(contours) {
+        const reversed = new Array(contours.length);
+        for (let i = 0; i < contours.length; i++) {
+            reversed[i] = this.reverseContour(contours[i]);
+        }
+        return reversed;
+    }
+    reverseContour(contour) {
+        const len = contour.length;
+        if (len === 0)
+            return [];
+        const isClosed = len >= 4 &&
+            contour[0] === contour[len - 2] &&
+            contour[1] === contour[len - 1];
+        const end = isClosed ? len - 2 : len;
+        if (end === 0)
+            return [];
+        const reversed = new Array(end + 2);
+        let out = 0;
+        for (let i = end - 2; i >= 0; i -= 2) {
+            reversed[out++] = contour[i];
+            reversed[out++] = contour[i + 1];
+        }
+        if (out >= 2) {
+            reversed[out++] = reversed[0];
+            reversed[out++] = reversed[1];
+        }
+        return reversed;
+    }
+    performTessellation(contours, mode) {
+        const tess = new dt();
+        tess.gluTessProperty(H.WINDING_RULE, Y.NONZERO);
+        const vertices = [];
+        const indices = [];
+        const contourIndices = [];
+        let currentContour = [];
+        if (mode === 'boundary') {
+            tess.gluTessProperty(H.BOUNDARY_ONLY, 1);
+        }
+        if (mode === 'triangles') {
+            tess.gluTessCallback(H.VERTEX_DATA, (data) => {
+                indices.push(data);
+            });
+        }
+        else {
+            tess.gluTessCallback(H.BEGIN, () => {
+                currentContour = [];
+            });
+            tess.gluTessCallback(H.VERTEX_DATA, (data) => {
+                currentContour.push(data);
+            });
+            tess.gluTessCallback(H.END, () => {
+                if (currentContour.length > 0) {
+                    contourIndices.push(currentContour);
+                }
+            });
+        }
+        tess.gluTessCallback(H.COMBINE, (coords) => {
+            const idx = vertices.length / 2;
+            vertices.push(coords[0], coords[1]);
+            return idx;
+        });
+        tess.gluTessCallback(H.ERROR, (errno) => {
+            logger.warn(`libtess error: ${errno}`);
+        });
+        tess.gluTessNormal(0, 0, 1);
+        tess.gluTessBeginPolygon();
+        for (const contour of contours) {
+            tess.gluTessBeginContour();
+            for (let i = 0; i < contour.length; i += 2) {
+                const idx = vertices.length / 2;
+                vertices.push(contour[i], contour[i + 1]);
+                tess.gluTessVertex([contour[i], contour[i + 1]], idx);
+            }
+            tess.gluTessEndContour();
+        }
+        tess.gluTessEndPolygon();
+        if (vertices.length === 0) {
+            return null;
+        }
+        if (mode === 'triangles') {
+            return { vertices, indices };
+        }
+        else {
+            return { vertices, contourIndices };
+        }
+    }
+    boundaryToContours(boundaryResult) {
+        if (!boundaryResult.contourIndices) {
+            return [];
+        }
+        const contours = [];
+        for (const indices of boundaryResult.contourIndices) {
+            const contour = [];
+            for (const idx of indices) {
+                const vertIdx = idx * 2;
+                contour.push(boundaryResult.vertices[vertIdx], boundaryResult.vertices[vertIdx + 1]);
+            }
+            if (contour.length > 2) {
+                if (contour[0] !== contour[contour.length - 2] ||
+                    contour[1] !== contour[contour.length - 1]) {
+                    contour.push(contour[0], contour[1]);
+                }
+            }
+            contours.push(contour);
+        }
+        return contours;
+    }
+    // Check if contours need winding normalization via boundary pass
+    // Returns false if topology is simple enough to skip the expensive pass
+    needsWindingNormalization(contours) {
+        if (contours.length === 0)
+            return false;
+        // Heuristic 1: Single contour never needs normalization
+        if (contours.length === 1)
+            return false;
+        // Heuristic 2: All same winding = all outers, no holes
+        // Compute signed areas
+        let firstSign = null;
+        for (const contour of contours) {
+            const area = this.signedArea(contour);
+            const sign = area >= 0 ? 1 : -1;
+            if (firstSign === null) {
+                firstSign = sign;
+            }
+            else if (sign !== firstSign) {
+                // Mixed winding detected → might have holes or complex topology
+                return true;
+            }
+        }
+        // All same winding → simple topology, no normalization needed
+        return false;
+    }
+    // Compute signed area (CCW = positive, CW = negative)
+    signedArea(contour) {
+        let area = 0;
+        const len = contour.length;
+        if (len < 6)
+            return 0; // Need at least 3 points
+        for (let i = 0; i < len; i += 2) {
+            const x1 = contour[i];
+            const y1 = contour[i + 1];
+            const x2 = contour[(i + 2) % len];
+            const y2 = contour[(i + 3) % len];
+            area += x1 * y2 - x2 * y1;
+        }
+        return area / 2;
+    }
+}
+
+class Extruder {
+    constructor() { }
+    extrude(geometry, depth = 0, unitsPerEm) {
+        const points = geometry.triangles.vertices;
+        const triangleIndices = geometry.triangles.indices;
+        const contours = geometry.contours;
+        const contoursAreBoundary = geometry.contoursAreBoundary === true;
+        const pointLen = points.length;
+        const numPoints = pointLen / 2;
+        // Use boundary contours for side walls when available
+        let boundaryEdges = [];
+        let sideEdgeCount = 0;
+        let useContours = false;
+        if (depth !== 0) {
+            if (contoursAreBoundary && contours.length > 0) {
+                useContours = true;
+                for (const contour of contours) {
+                    const contourPointCount = contour.length >> 1;
+                    if (contourPointCount >= 2) {
+                        sideEdgeCount += contourPointCount - 1;
+                    }
+                }
+            }
+            else {
+                // Use a directionless key (min/max) to detect shared edges
+                // Store the directed edge (a->b) and mark as null when seen twice
+                const edgeMap = new Map();
+                const triLen = triangleIndices.length;
+                for (let i = 0; i < triLen; i += 3) {
+                    const a = triangleIndices[i];
+                    const b = triangleIndices[i + 1];
+                    const c = triangleIndices[i + 2];
+                    let key, packed;
+                    if (a < b) {
+                        key = (a << 16) | b;
+                    }
+                    else {
+                        key = (b << 16) | a;
+                    }
+                    packed = (a << 16) | b;
+                    let data = edgeMap.get(key);
+                    if (data === undefined) {
+                        edgeMap.set(key, packed);
+                    }
+                    else if (data !== null) {
+                        edgeMap.set(key, null);
+                    }
+                    if (b < c) {
+                        key = (b << 16) | c;
+                    }
+                    else {
+                        key = (c << 16) | b;
+                    }
+                    packed = (b << 16) | c;
+                    data = edgeMap.get(key);
+                    if (data === undefined) {
+                        edgeMap.set(key, packed);
+                    }
+                    else if (data !== null) {
+                        edgeMap.set(key, null);
+                    }
+                    if (c < a) {
+                        key = (c << 16) | a;
+                    }
+                    else {
+                        key = (a << 16) | c;
+                    }
+                    packed = (c << 16) | a;
+                    data = edgeMap.get(key);
+                    if (data === undefined) {
+                        edgeMap.set(key, packed);
+                    }
+                    else if (data !== null) {
+                        edgeMap.set(key, null);
+                    }
+                }
+                boundaryEdges = [];
+                for (const packedEdge of edgeMap.values()) {
+                    if (packedEdge === null)
+                        continue;
+                    boundaryEdges.push(packedEdge >>> 16, packedEdge & 0xffff);
+                }
+                sideEdgeCount = boundaryEdges.length >> 1;
+            }
+        }
+        const sideVertexCount = sideEdgeCount * 4;
+        const baseVertexCount = depth === 0 ? numPoints : numPoints * 2;
+        const vertexCount = baseVertexCount + sideVertexCount;
+        const vertices = new Float32Array(vertexCount * 3);
+        const normals = new Float32Array(vertexCount * 3);
+        const indexCount = depth === 0
+            ? triangleIndices.length
+            : triangleIndices.length * 2 + sideEdgeCount * 6;
+        const indices = new Uint32Array(indexCount);
+        if (depth === 0) {
+            for (let p = 0, vPos = 0; p < pointLen; p += 2, vPos += 3) {
+                vertices[vPos] = points[p];
+                vertices[vPos + 1] = points[p + 1];
+                vertices[vPos + 2] = 0;
+                normals[vPos] = 0;
+                normals[vPos + 1] = 0;
+                normals[vPos + 2] = 1;
+            }
+            indices.set(triangleIndices);
+            return { vertices, normals, indices };
+        }
+        const minBackOffset = unitsPerEm * 0.000025;
+        const backZ = depth <= minBackOffset ? minBackOffset : depth;
+        const backOffset = numPoints * 3;
+        for (let p = 0, vi = 0, base0 = 0; p < pointLen; p += 2, vi++, base0 += 3) {
+            const x = points[p];
+            const y = points[p + 1];
+            // Cap at z=0
+            vertices[base0] = x;
+            vertices[base0 + 1] = y;
+            vertices[base0 + 2] = 0;
+            normals[base0] = 0;
+            normals[base0 + 1] = 0;
+            normals[base0 + 2] = -1;
+            // Cap at z=depth
+            const baseD = base0 + backOffset;
+            vertices[baseD] = x;
+            vertices[baseD + 1] = y;
+            vertices[baseD + 2] = backZ;
+            normals[baseD] = 0;
+            normals[baseD + 1] = 0;
+            normals[baseD + 2] = 1;
+        }
+        // Front cap faces -Z, reverse winding from libtess CCW output
+        const triLen = triangleIndices.length;
+        for (let i = 0; i < triLen; i++) {
+            indices[i] = triangleIndices[triLen - 1 - i];
+        }
+        // Back cap faces +Z, use original winding
+        for (let i = 0; i < triLen; i++) {
+            indices[triLen + i] = triangleIndices[i] + numPoints;
+        }
+        let nextVertex = numPoints * 2;
+        let idxPos = triLen * 2;
+        if (useContours) {
+            for (const contour of contours) {
+                const contourLen = contour.length;
+                if (contourLen < 4)
+                    continue;
+                for (let i = 0; i < contourLen - 2; i += 2) {
+                    const p0x = contour[i];
+                    const p0y = contour[i + 1];
+                    const p1x = contour[i + 2];
+                    const p1y = contour[i + 3];
+                    const ex = p1x - p0x;
+                    const ey = p1y - p0y;
+                    const lenSq = ex * ex + ey * ey;
+                    let nx = 0;
+                    let ny = 0;
+                    if (lenSq > 1e-10) {
+                        const invLen = 1 / Math.sqrt(lenSq);
+                        nx = ey * invLen;
+                        ny = -ex * invLen;
+                    }
+                    const base = nextVertex * 3;
+                    vertices[base] = p0x;
+                    vertices[base + 1] = p0y;
+                    vertices[base + 2] = 0;
+                    vertices[base + 3] = p1x;
+                    vertices[base + 4] = p1y;
+                    vertices[base + 5] = 0;
+                    vertices[base + 6] = p0x;
+                    vertices[base + 7] = p0y;
+                    vertices[base + 8] = backZ;
+                    vertices[base + 9] = p1x;
+                    vertices[base + 10] = p1y;
+                    vertices[base + 11] = backZ;
+                    normals[base] = nx;
+                    normals[base + 1] = ny;
+                    normals[base + 2] = 0;
+                    normals[base + 3] = nx;
+                    normals[base + 4] = ny;
+                    normals[base + 5] = 0;
+                    normals[base + 6] = nx;
+                    normals[base + 7] = ny;
+                    normals[base + 8] = 0;
+                    normals[base + 9] = nx;
+                    normals[base + 10] = ny;
+                    normals[base + 11] = 0;
+                    const baseVertex = nextVertex;
+                    indices[idxPos] = baseVertex;
+                    indices[idxPos + 1] = baseVertex + 1;
+                    indices[idxPos + 2] = baseVertex + 2;
+                    indices[idxPos + 3] = baseVertex + 1;
+                    indices[idxPos + 4] = baseVertex + 3;
+                    indices[idxPos + 5] = baseVertex + 2;
+                    idxPos += 6;
+                    nextVertex += 4;
+                }
+            }
+        }
+        else {
+            for (let e = 0; e < sideEdgeCount; e++) {
+                const edgeIndex = e << 1;
+                const u = boundaryEdges[edgeIndex];
+                const v = boundaryEdges[edgeIndex + 1];
+                const u2 = u << 1;
+                const v2 = v << 1;
+                const p0x = points[u2];
+                const p0y = points[u2 + 1];
+                const p1x = points[v2];
+                const p1y = points[v2 + 1];
+                const ex = p1x - p0x;
+                const ey = p1y - p0y;
+                const lenSq = ex * ex + ey * ey;
+                let nx = 0;
+                let ny = 0;
+                if (lenSq > 1e-10) {
+                    const invLen = 1 / Math.sqrt(lenSq);
+                    nx = ey * invLen;
+                    ny = -ex * invLen;
+                }
+                const base = nextVertex * 3;
+                vertices[base] = p0x;
+                vertices[base + 1] = p0y;
+                vertices[base + 2] = 0;
+                vertices[base + 3] = p1x;
+                vertices[base + 4] = p1y;
+                vertices[base + 5] = 0;
+                vertices[base + 6] = p0x;
+                vertices[base + 7] = p0y;
+                vertices[base + 8] = backZ;
+                vertices[base + 9] = p1x;
+                vertices[base + 10] = p1y;
+                vertices[base + 11] = backZ;
+                normals[base] = nx;
+                normals[base + 1] = ny;
+                normals[base + 2] = 0;
+                normals[base + 3] = nx;
+                normals[base + 4] = ny;
+                normals[base + 5] = 0;
+                normals[base + 6] = nx;
+                normals[base + 7] = ny;
+                normals[base + 8] = 0;
+                normals[base + 9] = nx;
+                normals[base + 10] = ny;
+                normals[base + 11] = 0;
+                const baseVertex = nextVertex;
+                indices[idxPos] = baseVertex;
+                indices[idxPos + 1] = baseVertex + 1;
+                indices[idxPos + 2] = baseVertex + 2;
+                indices[idxPos + 3] = baseVertex + 1;
+                indices[idxPos + 4] = baseVertex + 3;
+                indices[idxPos + 5] = baseVertex + 2;
+                idxPos += 6;
+                nextVertex += 4;
+            }
+        }
+        return { vertices, normals, indices };
+    }
+}
+
+const OVERLAP_EPSILON = 1e-3;
+class BoundaryClusterer {
+    constructor() { }
+    cluster(glyphContoursList, positions) {
+        perfLogger.start('BoundaryClusterer.cluster', {
+            glyphCount: glyphContoursList.length
+        });
+        const n = glyphContoursList.length;
+        if (n === 0) {
+            perfLogger.end('BoundaryClusterer.cluster');
+            return [];
+        }
+        if (n === 1) {
+            perfLogger.end('BoundaryClusterer.cluster');
+            return [[0]];
+        }
+        const result = this.clusterSweepLine(glyphContoursList, positions);
+        perfLogger.end('BoundaryClusterer.cluster');
+        return result;
+    }
+    clusterSweepLine(glyphContoursList, positions) {
+        const n = glyphContoursList.length;
+        const bounds = new Array(n);
+        const events = new Array(2 * n);
+        let eventIndex = 0;
+        for (let i = 0; i < n; i++) {
+            bounds[i] = this.getWorldBounds(glyphContoursList[i], positions[i]);
+            events[eventIndex++] = [bounds[i].minX, 0, i];
+            events[eventIndex++] = [bounds[i].maxX, 1, i];
+        }
+        events.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+        const parent = Array.from({ length: n }, (_, i) => i);
+        const rank = new Array(n).fill(0);
+        function find(x) {
+            return parent[x] === x ? x : (parent[x] = find(parent[x]));
+        }
+        function union(x, y) {
+            const px = find(x);
+            const py = find(y);
+            if (px === py)
+                return;
+            if (rank[px] < rank[py]) {
+                parent[px] = py;
+            }
+            else if (rank[px] > rank[py]) {
+                parent[py] = px;
+            }
+            else {
+                parent[py] = px;
+                rank[px]++;
+            }
+        }
+        const active = new Set();
+        for (const [, eventType, glyphIndex] of events) {
+            if (eventType === 0) {
+                const bounds1 = bounds[glyphIndex];
+                for (const activeIndex of active) {
+                    const bounds2 = bounds[activeIndex];
+                    if (bounds1.minY < bounds2.maxY + OVERLAP_EPSILON &&
+                        bounds1.maxY > bounds2.minY - OVERLAP_EPSILON) {
+                        union(glyphIndex, activeIndex);
+                    }
+                }
+                active.add(glyphIndex);
+            }
+            else {
+                active.delete(glyphIndex);
+            }
+        }
+        const clusters = new Map();
+        for (let i = 0; i < n; i++) {
+            const root = find(i);
+            let list = clusters.get(root);
+            if (!list) {
+                list = [];
+                clusters.set(root, list);
+            }
+            list.push(i);
+        }
+        return Array.from(clusters.values());
+    }
+    getWorldBounds(contours, position) {
+        return {
+            minX: contours.bounds.min.x + position.x,
+            minY: contours.bounds.min.y + position.y,
+            maxX: contours.bounds.max.x + position.x,
+            maxY: contours.bounds.max.y + position.y
+        };
+    }
+}
+
+const DEFAULT_OPTIMIZATION_CONFIG = {
+    enabled: true,
+    areaThreshold: 1.0
+};
+// Scratch buffers reused across calls. Grown on demand, never shrunk
+let _cap = 1024;
+let _px = new Float64Array(_cap);
+let _py = new Float64Array(_cap);
+let _area = new Float64Array(_cap);
+let _prev = new Int32Array(_cap);
+let _next = new Int32Array(_cap);
+let _heap = new Int32Array(_cap);
+let _hpos = new Int32Array(_cap);
+function ensureCap(n) {
+    if (n <= _cap)
+        return;
+    _cap = 1;
+    while (_cap < n)
+        _cap <<= 1;
+    _px = new Float64Array(_cap);
+    _py = new Float64Array(_cap);
+    _area = new Float64Array(_cap);
+    _prev = new Int32Array(_cap);
+    _next = new Int32Array(_cap);
+    _heap = new Int32Array(_cap);
+    _hpos = new Int32Array(_cap);
+}
+class PathOptimizer {
+    constructor(config) {
+        this.stats = {
+            pointsRemovedByVisvalingam: 0,
+            originalPointCount: 0
+        };
+        this.config = config;
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    optimizePath(path) {
+        const points = path.points;
+        const n = points.length;
+        if (n < 5 || !this.config.enabled) {
+            if (this.config.enabled)
+                this.stats.originalPointCount += n;
+            return path;
+        }
+        this.stats.originalPointCount += n;
+        const removed = simplifyVW(points, n, this.config.areaThreshold);
+        if (removed === 0)
+            return path;
+        this.stats.pointsRemovedByVisvalingam += removed;
+        const result = new Array(n - removed);
+        let idx = 0;
+        let out = 0;
+        while (idx >= 0) {
+            result[out++] = points[idx];
+            idx = _next[idx];
+        }
+        return { ...path, points: result };
+    }
+    getStats() {
+        return { ...this.stats };
+    }
+    resetStats() {
+        this.stats = {
+            pointsRemovedByVisvalingam: 0,
+            originalPointCount: 0
+        };
+    }
+}
+// Visvalingam-Whyatt simplification. Iteratively removes the point
+// whose removal causes the smallest change in contour area (measured
+// as the triangle formed with its two neighbors) until all remaining
+// triangles exceed areaThreshold
+//
+// Uses parallel typed arrays for the linked list and a binary min-heap
+// with an index-based position map for O(log n) extract and update.
+// Coordinates are flattened into Float64Array to keep area computation
+// on contiguous memory. Areas are stored as 2x actual (skipping the
+// shoelace /2) and the threshold is doubled to match
+//
+// Returns the number of points removed. The caller reads _next[] to
+// walk the surviving linked list
+function simplifyVW(points, n, areaThreshold) {
+    if (n <= 3)
+        return 0;
+    ensureCap(n);
+    const px = _px;
+    const py = _py;
+    const area = _area;
+    const prev = _prev;
+    const next = _next;
+    const heap = _heap;
+    const hpos = _hpos;
+    // Flatten coordinates and initialize doubly-linked list
+    for (let i = 0; i < n; i++) {
+        const p = points[i];
+        px[i] = p.x;
+        py[i] = p.y;
+        prev[i] = i - 1;
+        next[i] = i + 1;
+    }
+    next[n - 1] = -1;
+    // Compute triangle areas for interior points and seed the heap
+    const heapLen0 = n - 2;
+    area[0] = Infinity;
+    area[n - 1] = Infinity;
+    for (let i = 1; i < n - 1; i++) {
+        area[i] = area2x(px, py, i - 1, i, i + 1);
+        heap[i - 1] = i;
+        hpos[i] = i - 1;
+    }
+    hpos[0] = -1;
+    hpos[n - 1] = -1;
+    // Bottom-up heapify, O(n)
+    let heapLen = heapLen0;
+    for (let i = (heapLen >> 1) - 1; i >= 0; i--) {
+        siftDown(heap, hpos, area, i, heapLen);
+    }
+    const threshold2x = areaThreshold * 2;
+    const maxRemovals = n - 3;
+    let removed = 0;
+    while (heapLen > 0 && removed < maxRemovals) {
+        const minIdx = heap[0];
+        if (area[minIdx] > threshold2x)
+            break;
+        // Extract min
+        heapLen--;
+        if (heapLen > 0) {
+            const last = heap[heapLen];
+            heap[0] = last;
+            hpos[last] = 0;
+            siftDown(heap, hpos, area, 0, heapLen);
+        }
+        hpos[minIdx] = -1;
+        // Unlink
+        const pi = prev[minIdx];
+        const ni = next[minIdx];
+        if (pi >= 0)
+            next[pi] = ni;
+        if (ni >= 0)
+            prev[ni] = pi;
+        removed++;
+        // Recompute prev neighbor's area and update heap position
+        if (pi >= 0 && prev[pi] >= 0) {
+            const oldArea = area[pi];
+            const newArea = area2x(px, py, prev[pi], pi, ni);
+            area[pi] = newArea;
+            const pos = hpos[pi];
+            if (pos >= 0) {
+                if (newArea < oldArea)
+                    siftUp(heap, hpos, area, pos);
+                else if (newArea > oldArea)
+                    siftDown(heap, hpos, area, pos, heapLen);
+            }
+        }
+        // Same for next neighbor
+        if (ni >= 0 && next[ni] >= 0) {
+            const oldArea = area[ni];
+            const newArea = area2x(px, py, pi, ni, next[ni]);
+            area[ni] = newArea;
+            const pos = hpos[ni];
+            if (pos >= 0) {
+                if (newArea < oldArea)
+                    siftUp(heap, hpos, area, pos);
+                else if (newArea > oldArea)
+                    siftDown(heap, hpos, area, pos, heapLen);
+            }
+        }
+    }
+    return removed;
+}
+function siftUp(heap, hpos, area, i) {
+    const idx = heap[i];
+    const val = area[idx];
+    while (i > 0) {
+        const parent = (i - 1) >> 1;
+        const pidx = heap[parent];
+        if (area[pidx] <= val)
+            break;
+        heap[i] = pidx;
+        hpos[pidx] = i;
+        i = parent;
+    }
+    heap[i] = idx;
+    hpos[idx] = i;
+}
+function siftDown(heap, hpos, area, i, len) {
+    const idx = heap[i];
+    const val = area[idx];
+    const half = len >> 1;
+    while (i < half) {
+        let child = (i << 1) + 1;
+        let childIdx = heap[child];
+        let childVal = area[childIdx];
+        const right = child + 1;
+        if (right < len) {
+            const rIdx = heap[right];
+            const rVal = area[rIdx];
+            if (rVal < childVal) {
+                child = right;
+                childIdx = rIdx;
+                childVal = rVal;
+            }
+        }
+        if (childVal >= val)
+            break;
+        heap[i] = childIdx;
+        hpos[childIdx] = i;
+        i = child;
+    }
+    heap[i] = idx;
+    hpos[idx] = i;
+}
+// Doubled triangle area via the shoelace formula. Skipping the /2
+// means callers compare against a doubled threshold instead
+function area2x(px, py, i1, i2, i3) {
+    const v = px[i1] * (py[i2] - py[i3]) +
+        px[i2] * (py[i3] - py[i1]) +
+        px[i3] * (py[i1] - py[i2]);
+    return v < 0 ? -v : v;
+}
+
+/**
+ * @license
+ * Anti-Grain Geometry - Version 2.4
+ * Copyright (C) 2002-2005 Maxim Shemanarev (McSeem)
+ *
+ * This software is a partial port of the AGG library, specifically the adaptive
+ * subdivision algorithm for polygonization. The original software was available
+ * at http://www.antigrain.com and was distributed under the BSD 3-Clause License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+const DEFAULT_CURVE_FIDELITY = {
+    distanceTolerance: 0.5,
+    angleTolerance: 0.2,
+    cuspLimit: 0,
+    collinearityEpsilon: 1e-6,
+    recursionLimit: 16
+};
+const COLLINEARITY_EPSILON = DEFAULT_CURVE_FIDELITY.collinearityEpsilon;
+// Module-level state for the recursive subdivision functions,
+// set from instance config before each polygonize call
+// Output array, reset before each polygonize call
+let _out;
+// Cached tolerance state
+let _distTolSq = 0;
+let _colEps = 0;
+let _maxLvl = 0;
+let _angleTol = 0;
+let _tanAngSq = 0;
+let _cuspLim = 0;
+let _tanCuspSq = 0;
+// Collinearity checks in the recursive core prevent near-duplicate points
+function emit(x, y) {
+    _out.push(new Vec2(x, y));
+}
+// Quadratic recursive subdivision (AGG curve3_div)
+function quadRec(x1, y1, x2, y2, x3, y3, level) {
+    if (level > _maxLvl)
+        return;
+    const x12 = (x1 + x2) * 0.5;
+    const y12 = (y1 + y2) * 0.5;
+    const x23 = (x2 + x3) * 0.5;
+    const y23 = (y2 + y3) * 0.5;
+    const x123 = (x12 + x23) * 0.5;
+    const y123 = (y12 + y23) * 0.5;
+    const dx = x3 - x1;
+    const dy = y3 - y1;
+    let d = Math.abs((x2 - x3) * dy - (y2 - y3) * dx);
+    if (d > _colEps) {
+        if (d * d <= _distTolSq * (dx * dx + dy * dy)) {
+            if (_angleTol > 0) {
+                const v1x = x2 - x1;
+                const v1y = y2 - y1;
+                const v2x = x3 - x2;
+                const v2y = y3 - y2;
+                const cross = v1x * v2y - v1y * v2x;
+                const dot = v1x * v2x + v1y * v2y;
+                if (dot > 0 && cross * cross < _tanAngSq * dot * dot) {
+                    emit(x123, y123);
+                    return;
+                }
+            }
+            else {
+                emit(x123, y123);
+                return;
+            }
+        }
+    }
+    else {
+        let da = dx * dx + dy * dy;
+        if (da === 0) {
+            d = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
+        }
+        else {
+            d = ((x2 - x1) * dx + (y2 - y1) * dy) / da;
+            if (d > 0 && d < 1)
+                return;
+            if (d <= 0)
+                d = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
+            else if (d >= 1)
+                d = (x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3);
+            else {
+                const px = x1 + d * dx;
+                const py = y1 + d * dy;
+                d = (x2 - px) * (x2 - px) + (y2 - py) * (y2 - py);
+            }
+        }
+        if (d < _distTolSq) {
+            emit(x2, y2);
+            return;
+        }
+    }
+    const nl = level + 1;
+    quadRec(x1, y1, x12, y12, x123, y123, nl);
+    quadRec(x123, y123, x23, y23, x3, y3, nl);
+}
+// Cubic recursive subdivision (AGG curve4_div)
+// cubicBegin handles level 0, which always subdivides
+function cubicBegin(x1, y1, x2, y2, x3, y3, x4, y4) {
+    const x12 = (x1 + x2) * 0.5;
+    const y12 = (y1 + y2) * 0.5;
+    const x23 = (x2 + x3) * 0.5;
+    const y23 = (y2 + y3) * 0.5;
+    const x34 = (x3 + x4) * 0.5;
+    const y34 = (y3 + y4) * 0.5;
+    const x123 = (x12 + x23) * 0.5;
+    const y123 = (y12 + y23) * 0.5;
+    const x234 = (x23 + x34) * 0.5;
+    const y234 = (y23 + y34) * 0.5;
+    const x1234 = (x123 + x234) * 0.5;
+    const y1234 = (y123 + y234) * 0.5;
+    cubicRec(x1, y1, x12, y12, x123, y123, x1234, y1234, 1);
+    cubicRec(x1234, y1234, x234, y234, x34, y34, x4, y4, 1);
+}
+function cubicRec(x1, y1, x2, y2, x3, y3, x4, y4, level) {
+    if (level > _maxLvl)
+        return;
+    const x12 = (x1 + x2) * 0.5;
+    const y12 = (y1 + y2) * 0.5;
+    const x23 = (x2 + x3) * 0.5;
+    const y23 = (y2 + y3) * 0.5;
+    const x34 = (x3 + x4) * 0.5;
+    const y34 = (y3 + y4) * 0.5;
+    const x123 = (x12 + x23) * 0.5;
+    const y123 = (y12 + y23) * 0.5;
+    const x234 = (x23 + x34) * 0.5;
+    const y234 = (y23 + y34) * 0.5;
+    const x1234 = (x123 + x234) * 0.5;
+    const y1234 = (y123 + y234) * 0.5;
+    const dx = x4 - x1;
+    const dy = y4 - y1;
+    let d2 = Math.abs((x2 - x4) * dy - (y2 - y4) * dx);
+    let d3 = Math.abs((x3 - x4) * dy - (y3 - y4) * dx);
+    const sc = (d2 > _colEps ? 2 : 0) + (d3 > _colEps ? 1 : 0);
+    switch (sc) {
+        case 0: {
+            let k = dx * dx + dy * dy;
+            if (k === 0) {
+                d2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
+                d3 = (x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1);
+            }
+            else {
+                k = 1 / k;
+                let t1 = x2 - x1;
+                let t2 = y2 - y1;
+                d2 = k * (t1 * dx + t2 * dy);
+                t1 = x3 - x1;
+                t2 = y3 - y1;
+                d3 = k * (t1 * dx + t2 * dy);
+                if (d2 > 0 && d2 < 1 && d3 > 0 && d3 < 1)
+                    return;
+                if (d2 <= 0)
+                    d2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
+                else if (d2 >= 1)
+                    d2 = (x2 - x4) * (x2 - x4) + (y2 - y4) * (y2 - y4);
+                else {
+                    const px = x1 + d2 * dx, py = y1 + d2 * dy;
+                    d2 = (x2 - px) * (x2 - px) + (y2 - py) * (y2 - py);
+                }
+                if (d3 <= 0)
+                    d3 = (x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1);
+                else if (d3 >= 1)
+                    d3 = (x3 - x4) * (x3 - x4) + (y3 - y4) * (y3 - y4);
+                else {
+                    const px = x1 + d3 * dx, py = y1 + d3 * dy;
+                    d3 = (x3 - px) * (x3 - px) + (y3 - py) * (y3 - py);
+                }
+            }
+            if (d2 > d3) {
+                if (d2 < _distTolSq) {
+                    emit(x2, y2);
+                    return;
+                }
+            }
+            else {
+                if (d3 < _distTolSq) {
+                    emit(x3, y3);
+                    return;
+                }
+            }
+            break;
+        }
+        case 1:
+            if (d3 * d3 <= _distTolSq * (dx * dx + dy * dy)) {
+                if (_angleTol > 0) {
+                    const v1x = x3 - x2, v1y = y3 - y2;
+                    const v2x = x4 - x3, v2y = y4 - y3;
+                    const cross = v1x * v2y - v1y * v2x;
+                    const dot = v1x * v2x + v1y * v2y;
+                    if (dot > 0 && cross * cross < _tanAngSq * dot * dot) {
+                        emit(x2, y2);
+                        emit(x3, y3);
+                        return;
+                    }
+                    if (_cuspLim > 0 &&
+                        (dot <= 0 || cross * cross > _tanCuspSq * dot * dot)) {
+                        emit(x3, y3);
+                        return;
+                    }
+                }
+                else {
+                    emit(x23, y23);
+                    return;
+                }
+            }
+            break;
+        case 2:
+            if (d2 * d2 <= _distTolSq * (dx * dx + dy * dy)) {
+                if (_angleTol > 0) {
+                    const v1x = x2 - x1, v1y = y2 - y1;
+                    const v2x = x3 - x2, v2y = y3 - y2;
+                    const cross = v1x * v2y - v1y * v2x;
+                    const dot = v1x * v2x + v1y * v2y;
+                    if (dot > 0 && cross * cross < _tanAngSq * dot * dot) {
+                        emit(x2, y2);
+                        emit(x3, y3);
+                        return;
+                    }
+                    if (_cuspLim > 0 &&
+                        (dot <= 0 || cross * cross > _tanCuspSq * dot * dot)) {
+                        emit(x2, y2);
+                        return;
+                    }
+                }
+                else {
+                    emit(x23, y23);
+                    return;
+                }
+            }
+            break;
+        case 3: {
+            if ((d2 + d3) * (d2 + d3) <= _distTolSq * (dx * dx + dy * dy)) {
+                if (_angleTol > 0) {
+                    const a1x = x2 - x1, a1y = y2 - y1;
+                    const a2x = x3 - x2, a2y = y3 - y2;
+                    const c1 = a1x * a2y - a1y * a2x;
+                    const dot1 = a1x * a2x + a1y * a2y;
+                    const b2x = x4 - x3, b2y = y4 - y3;
+                    const c2 = a2x * b2y - a2y * b2x;
+                    const dot2 = a2x * b2x + a2y * b2y;
+                    // Sum of unsigned angles via tangent addition identity
+                    if (dot1 > 0 && dot2 > 0) {
+                        const ac1 = c1 < 0 ? -c1 : c1;
+                        const ac2 = c2 < 0 ? -c2 : c2;
+                        const cc = ac1 * dot2 + ac2 * dot1;
+                        const cd = dot1 * dot2 - ac1 * ac2;
+                        if (cd > 0 && cc * cc < _tanAngSq * cd * cd) {
+                            emit(x23, y23);
+                            return;
+                        }
+                    }
+                    if (_cuspLim > 0) {
+                        if (dot1 <= 0 || c1 * c1 > _tanCuspSq * dot1 * dot1) {
+                            emit(x2, y2);
+                            return;
+                        }
+                        if (dot2 <= 0 || c2 * c2 > _tanCuspSq * dot2 * dot2) {
+                            emit(x3, y3);
+                            return;
+                        }
+                    }
+                }
+                else {
+                    emit(x23, y23);
+                    return;
+                }
+            }
+            break;
+        }
+    }
+    const nl = level + 1;
+    cubicRec(x1, y1, x12, y12, x123, y123, x1234, y1234, nl);
+    cubicRec(x1234, y1234, x234, y234, x34, y34, x4, y4, nl);
+}
+class Polygonizer {
+    constructor(curveFidelityConfig) {
+        this.curveSteps = null;
+        // Precomputed tolerances
+        this._distTolSq = 0;
+        this._angleTol = 0;
+        this._tanAngSq = 0;
+        this._cuspLim = 0;
+        this._tanCuspSq = 0;
+        this._colEps = 0;
+        this._maxLvl = 0;
+        this.curveFidelityConfig = {
+            ...DEFAULT_CURVE_FIDELITY,
+            ...curveFidelityConfig
+        };
+        this.precompute();
+    }
+    setCurveFidelityConfig(curveFidelityConfig) {
+        this.curveFidelityConfig = {
+            ...DEFAULT_CURVE_FIDELITY,
+            ...curveFidelityConfig
+        };
+        this.precompute();
+    }
+    precompute() {
+        const c = this.curveFidelityConfig;
+        const dt = c.distanceTolerance ?? DEFAULT_CURVE_FIDELITY.distanceTolerance;
+        this._distTolSq = dt * dt;
+        this._angleTol = c.angleTolerance ?? DEFAULT_CURVE_FIDELITY.angleTolerance;
+        this._tanAngSq = this._angleTol > 0
+            ? Math.tan(this._angleTol) ** 2 : 0;
+        this._cuspLim = c.cuspLimit ?? 0;
+        this._tanCuspSq = this._cuspLim > 0
+            ? Math.tan(this._cuspLim) ** 2 : 0;
+        this._colEps = c.collinearityEpsilon ?? DEFAULT_CURVE_FIDELITY.collinearityEpsilon;
+        this._maxLvl = c.recursionLimit ?? DEFAULT_CURVE_FIDELITY.recursionLimit;
+    }
+    // Set module-level state from instance tolerances
+    activate() {
+        _distTolSq = this._distTolSq;
+        _angleTol = this._angleTol;
+        _tanAngSq = this._tanAngSq;
+        _cuspLim = this._cuspLim;
+        _tanCuspSq = this._tanCuspSq;
+        _colEps = this._colEps;
+        _maxLvl = this._maxLvl;
+        _out = [];
+    }
+    // Fixed-step subdivision; overrides adaptive curveFidelity when set
+    setCurveSteps(curveSteps) {
+        if (curveSteps === undefined || curveSteps === null) {
+            this.curveSteps = null;
+            return;
+        }
+        if (!Number.isFinite(curveSteps)) {
+            this.curveSteps = null;
+            return;
+        }
+        const stepsInt = Math.round(curveSteps);
+        this.curveSteps = stepsInt >= 1 ? stepsInt : null;
+    }
+    polygonizeQuadratic(start, control, end) {
+        if (this.curveSteps !== null) {
+            return this.polygonizeQuadraticFixedSteps(start, control, end, this.curveSteps);
+        }
+        this.activate();
+        quadRec(start.x, start.y, control.x, control.y, end.x, end.y, 0);
+        emit(end.x, end.y);
+        return _out;
+    }
+    polygonizeCubic(start, control1, control2, end) {
+        if (this.curveSteps !== null) {
+            return this.polygonizeCubicFixedSteps(start, control1, control2, end, this.curveSteps);
+        }
+        this.activate();
+        cubicBegin(start.x, start.y, control1.x, control1.y, control2.x, control2.y, end.x, end.y);
+        emit(end.x, end.y);
+        return _out;
+    }
+    polygonizeQuadraticFixedSteps(start, control, end, steps) {
+        this.activate();
+        for (let i = 1; i <= steps; i++) {
+            const t = i / steps;
+            const x12 = start.x + (control.x - start.x) * t;
+            const y12 = start.y + (control.y - start.y) * t;
+            const x23 = control.x + (end.x - control.x) * t;
+            const y23 = control.y + (end.y - control.y) * t;
+            emit(x12 + (x23 - x12) * t, y12 + (y23 - y12) * t);
+        }
+        return _out;
+    }
+    polygonizeCubicFixedSteps(start, control1, control2, end, steps) {
+        this.activate();
+        for (let i = 1; i <= steps; i++) {
+            const t = i / steps;
+            const x12 = start.x + (control1.x - start.x) * t;
+            const y12 = start.y + (control1.y - start.y) * t;
+            const x23 = control1.x + (control2.x - control1.x) * t;
+            const y23 = control1.y + (control2.y - control1.y) * t;
+            const x34 = control2.x + (end.x - control2.x) * t;
+            const y34 = control2.y + (end.y - control2.y) * t;
+            const x123 = x12 + (x23 - x12) * t;
+            const y123 = y12 + (y23 - y12) * t;
+            const x234 = x23 + (x34 - x23) * t;
+            const y234 = y23 + (y34 - y23) * t;
+            emit(x123 + (x234 - x123) * t, y123 + (y234 - y123) * t);
+        }
+        return _out;
+    }
+}
+
+class GlyphContourCollector {
+    constructor(curveFidelityConfig, optimizationConfig) {
+        this.currentGlyphId = 0;
+        this.currentTextIndex = 0;
+        this.currentGlyphPaths = [];
+        this.currentPath = null;
+        this.currentPoint = null;
+        this.currentGlyphBounds = {
+            min: new Vec2(Infinity, Infinity),
+            max: new Vec2(-Infinity, -Infinity)
+        };
+        this.collectedGlyphs = [];
+        this.glyphPositions = [];
+        this.glyphTextIndices = [];
+        this.currentPosition = new Vec2(0, 0);
+        this.polygonizer = new Polygonizer(curveFidelityConfig);
+        this.pathOptimizer = new PathOptimizer({
+            ...DEFAULT_OPTIMIZATION_CONFIG,
+            ...optimizationConfig
+        });
+    }
+    setPosition(x, y) {
+        this.currentPosition.set(x, y);
+    }
+    updatePosition(dx, dy) {
+        this.currentPosition.x += dx;
+        this.currentPosition.y += dy;
+    }
+    beginGlyph(glyphId, textIndex) {
+        if (this.currentGlyphPaths.length > 0) {
+            this.finishGlyph();
+        }
+        this.currentGlyphId = glyphId;
+        this.currentTextIndex = textIndex;
+        this.currentGlyphPaths = [];
+        this.currentGlyphBounds.min.set(Infinity, Infinity);
+        this.currentGlyphBounds.max.set(-Infinity, -Infinity);
+        // Record position for this glyph
+        this.glyphPositions.push(this.currentPosition.clone());
+        // Time polygonization + path optimization per glyph
+        perfLogger.start('Glyph.polygonizeAndOptimize', {
+            glyphId,
+            textIndex
+        });
+    }
+    finishGlyph() {
+        if (this.currentPath) {
+            this.finishPath();
+        }
+        if (this.currentGlyphPaths.length > 0) {
+            this.collectedGlyphs.push({
+                glyphId: this.currentGlyphId,
+                paths: this.currentGlyphPaths,
+                bounds: {
+                    min: {
+                        x: this.currentGlyphBounds.min.x,
+                        y: this.currentGlyphBounds.min.y
+                    },
+                    max: {
+                        x: this.currentGlyphBounds.max.x,
+                        y: this.currentGlyphBounds.max.y
+                    }
+                }
+            });
+            // Track textIndex separately
+            this.glyphTextIndices.push(this.currentTextIndex);
+        }
+        // Stop timing for this glyph (even if it ended up empty)
+        perfLogger.end('Glyph.polygonizeAndOptimize');
+        this.currentGlyphPaths = [];
+    }
+    onMoveTo(x, y) {
+        if (this.currentPath) {
+            this.finishPath();
+        }
+        this.currentPoint = new Vec2(x, y);
+        this.updateBounds(this.currentPoint);
+        this.currentPath = {
+            points: [this.currentPoint],
+            glyphIndex: this.currentGlyphId
+        };
+    }
+    onLineTo(x, y) {
+        if (!this.currentPath || !this.currentPoint)
+            return;
+        const point = new Vec2(x, y);
+        this.updateBounds(point);
+        this.currentPath.points.push(point);
+        this.currentPoint = point;
+    }
+    onQuadTo(cx, cy, x, y) {
+        if (!this.currentPath || !this.currentPoint)
+            return;
+        const start = this.currentPoint;
+        const control = new Vec2(cx, cy);
+        const end = new Vec2(x, y);
+        const dx = end.x - start.x;
+        const dy = end.y - start.y;
+        const d = Math.abs((control.x - end.x) * dy - (control.y - end.y) * dx);
+        if (d < COLLINEARITY_EPSILON) {
+            this.onLineTo(x, y);
+            return;
+        }
+        const flattenedPoints = this.polygonizer.polygonizeQuadratic(start, control, end);
+        for (let i = 0; i < flattenedPoints.length; i++) {
+            const pt = flattenedPoints[i];
+            this.updateBounds(pt);
+            this.currentPath.points.push(pt);
+        }
+        this.currentPoint = end;
+    }
+    onCubicTo(c1x, c1y, c2x, c2y, x, y) {
+        if (!this.currentPath || !this.currentPoint)
+            return;
+        const start = this.currentPoint;
+        const control1 = new Vec2(c1x, c1y);
+        const control2 = new Vec2(c2x, c2y);
+        const end = new Vec2(x, y);
+        const dx = end.x - start.x;
+        const dy = end.y - start.y;
+        const d1 = Math.abs((control1.x - end.x) * dy - (control1.y - end.y) * dx);
+        const d2 = Math.abs((control2.x - end.x) * dy - (control2.y - end.y) * dx);
+        if (d1 < COLLINEARITY_EPSILON && d2 < COLLINEARITY_EPSILON) {
+            this.onLineTo(x, y);
+            return;
+        }
+        const flattenedPoints = this.polygonizer.polygonizeCubic(start, control1, control2, end);
+        for (let i = 0; i < flattenedPoints.length; i++) {
+            const pt = flattenedPoints[i];
+            this.updateBounds(pt);
+            this.currentPath.points.push(pt);
+        }
+        this.currentPoint = end;
+    }
+    onClosePath() {
+        if (!this.currentPath || !this.currentPoint)
+            return;
+        const firstPoint = this.currentPath.points[0];
+        if (!this.currentPoint.equals(firstPoint)) {
+            this.currentPath.points.push(firstPoint);
+        }
+        this.finishPath();
+    }
+    finishPath() {
+        if (this.currentPath) {
+            const path = this.pathOptimizer.optimizePath(this.currentPath);
+            this.currentGlyphPaths.push(path);
+            this.currentPath = null;
+            this.currentPoint = null;
+        }
+    }
+    updateBounds(point) {
+        this.currentGlyphBounds.min.x = Math.min(this.currentGlyphBounds.min.x, point.x);
+        this.currentGlyphBounds.min.y = Math.min(this.currentGlyphBounds.min.y, point.y);
+        this.currentGlyphBounds.max.x = Math.max(this.currentGlyphBounds.max.x, point.x);
+        this.currentGlyphBounds.max.y = Math.max(this.currentGlyphBounds.max.y, point.y);
+    }
+    getCollectedGlyphs() {
+        // Finish any pending glyph
+        if (this.currentGlyphPaths.length > 0) {
+            this.finishGlyph();
+        }
+        return this.collectedGlyphs;
+    }
+    getGlyphPositions() {
+        return this.glyphPositions;
+    }
+    getTextIndices() {
+        return this.glyphTextIndices;
+    }
+    reset() {
+        this.collectedGlyphs = [];
+        this.glyphPositions = [];
+        this.glyphTextIndices = [];
+        this.currentGlyphPaths = [];
+        this.currentPath = null;
+        this.currentPoint = null;
+        this.currentGlyphId = 0;
+        this.currentTextIndex = 0;
+        this.currentPosition.set(0, 0);
+        this.currentGlyphBounds = {
+            min: new Vec2(Infinity, Infinity),
+            max: new Vec2(-Infinity, -Infinity)
+        };
+    }
+    setCurveFidelityConfig(config) {
+        this.polygonizer.setCurveFidelityConfig(config);
+    }
+    setCurveSteps(curveSteps) {
+        this.polygonizer.setCurveSteps(curveSteps);
+    }
+    setGeometryOptimization(options) {
+        this.pathOptimizer.setConfig({
+            ...DEFAULT_OPTIMIZATION_CONFIG,
+            ...options
+        });
+    }
+    getOptimizationStats() {
+        return this.pathOptimizer.getStats();
+    }
+}
+
+class GlyphGeometryBuilder {
+    constructor(cache, loadedFont) {
+        this.fontId = 'default';
+        this.cacheKeyPrefix = 'default';
+        this.emptyGlyphs = new Set();
+        this.clusterPositions = [];
+        this.clusterContoursScratch = [];
+        this.taskScratch = [];
+        this.cache = cache;
+        this.loadedFont = loadedFont;
+        this.tessellator = new Tessellator();
+        this.extruder = new Extruder();
+        this.clusterer = new BoundaryClusterer();
+        this.collector = new GlyphContourCollector();
+        this.drawCallbacks = getSharedDrawCallbackHandler(this.loadedFont);
+        this.drawCallbacks.createDrawFuncs(this.loadedFont, this.collector);
+        this.contourCache = globalContourCache;
+        this.wordCache = globalWordCache;
+        this.clusteringCache = globalClusteringCache;
+    }
+    getOptimizationStats() {
+        return this.collector.getOptimizationStats();
+    }
+    setCurveFidelityConfig(config) {
+        this.curveFidelityConfig = config;
+        this.collector.setCurveFidelityConfig(config);
+        this.updateCacheKeyPrefix();
+    }
+    setCurveSteps(curveSteps) {
+        // Normalize: unset for undefined/null/non-finite/<=0
+        if (curveSteps === undefined || curveSteps === null) {
+            this.curveSteps = undefined;
+        }
+        else if (!Number.isFinite(curveSteps)) {
+            this.curveSteps = undefined;
+        }
+        else {
+            const stepsInt = Math.round(curveSteps);
+            this.curveSteps = stepsInt >= 1 ? stepsInt : undefined;
+        }
+        this.collector.setCurveSteps(this.curveSteps);
+        this.updateCacheKeyPrefix();
+    }
+    setGeometryOptimization(options) {
+        this.geometryOptimizationOptions = options;
+        this.collector.setGeometryOptimization(options);
+        this.updateCacheKeyPrefix();
+    }
+    setFontId(fontId) {
+        this.fontId = fontId;
+        this.updateCacheKeyPrefix();
+    }
+    updateCacheKeyPrefix() {
+        this.cacheKeyPrefix = `${this.fontId}__${this.getGeometryConfigSignature()}`;
+    }
+    getGeometryConfigSignature() {
+        const curveSignature = (() => {
+            if (this.curveSteps !== undefined) {
+                return `cf:steps:${this.curveSteps}`;
+            }
+            const distanceTolerance = this.curveFidelityConfig?.distanceTolerance ??
+                DEFAULT_CURVE_FIDELITY.distanceTolerance;
+            const angleTolerance = this.curveFidelityConfig?.angleTolerance ??
+                DEFAULT_CURVE_FIDELITY.angleTolerance;
+            return `cf:${distanceTolerance.toFixed(4)},${angleTolerance.toFixed(4)}`;
+        })();
+        const enabled = this.geometryOptimizationOptions?.enabled ??
+            DEFAULT_OPTIMIZATION_CONFIG.enabled;
+        const areaThreshold = this.geometryOptimizationOptions?.areaThreshold ??
+            DEFAULT_OPTIMIZATION_CONFIG.areaThreshold;
+        // Use fixed precision to keep cache keys stable and avoid float noise
+        return [
+            curveSignature,
+            `opt:${enabled ? 1 : 0},${areaThreshold.toFixed(4)}`
+        ].join('|');
+    }
+    buildInstancedGeometry(clustersByLine, depth, removeOverlaps, isCFF, scale, separateGlyphs = false, coloredTextIndices) {
+        if (isLogEnabled) {
+            let wordCount = 0;
+            for (let i = 0; i < clustersByLine.length; i++) {
+                wordCount += clustersByLine[i].length;
+            }
+            perfLogger.start('GlyphGeometryBuilder.buildInstancedGeometry', {
+                lineCount: clustersByLine.length,
+                wordCount,
+                depth,
+                removeOverlaps
+            });
+        }
+        else {
+            perfLogger.start('GlyphGeometryBuilder.buildInstancedGeometry');
+        }
+        const tasks = this.taskScratch;
+        tasks.length = 0;
+        let taskCount = 0;
+        let totalVertexFloats = 0;
+        let totalNormalFloats = 0;
+        let totalIndexCount = 0;
+        let vertexCursor = 0; // vertex offset (not float offset)
+        const pushTask = (data, px, py, pz) => {
+            const vertexStart = vertexCursor;
+            let task = tasks[taskCount];
+            if (task) {
+                task.data = data;
+                task.px = px;
+                task.py = py;
+                task.pz = pz;
+                task.vertexStart = vertexStart;
+            }
+            else {
+                task = { data, px, py, pz, vertexStart };
+                tasks[taskCount] = task;
+            }
+            taskCount++;
+            totalVertexFloats += data.vertices.length;
+            totalNormalFloats += data.normals.length;
+            totalIndexCount += data.indices.length;
+            vertexCursor += data.vertices.length / 3;
+            return vertexStart;
+        };
+        const glyphInfos = [];
+        const planeBounds = {
+            min: { x: Infinity, y: Infinity, z: 0 },
+            max: { x: -Infinity, y: -Infinity, z: depth }
+        };
+        for (let lineIndex = 0; lineIndex < clustersByLine.length; lineIndex++) {
+            const line = clustersByLine[lineIndex];
+            for (const cluster of line) {
+                const clusterX = cluster.position.x;
+                const clusterY = cluster.position.y;
+                const clusterZ = cluster.position.z;
+                const clusterGlyphContours = [];
+                for (const glyph of cluster.glyphs) {
+                    clusterGlyphContours.push(this.getContoursForGlyph(glyph.g));
+                }
+                let boundaryGroups;
+                if (cluster.glyphs.length <= 1) {
+                    boundaryGroups = [[0]];
+                }
+                else {
+                    // Check clustering cache (same text + glyph IDs + positions = same overlap groups)
+                    // Key must be font-specific; glyph ids/bounds differ between fonts
+                    // Positions must match since overlap detection depends on relative glyph placement
+                    const cacheKey = `${this.cacheKeyPrefix}_${cluster.text}`;
+                    const cached = this.clusteringCache.get(cacheKey);
+                    let isValid = false;
+                    if (cached && cached.glyphIds.length === cluster.glyphs.length) {
+                        isValid = true;
+                        for (let i = 0; i < cluster.glyphs.length; i++) {
+                            const glyph = cluster.glyphs[i];
+                            const cachedPos = cached.positions[i];
+                            if (cached.glyphIds[i] !== glyph.g ||
+                                cachedPos.x !== (glyph.x ?? 0) ||
+                                cachedPos.y !== (glyph.y ?? 0)) {
+                                isValid = false;
+                                break;
+                            }
+                        }
+                    }
+                    if (isValid && cached) {
+                        boundaryGroups = cached.groups;
+                    }
+                    else {
+                        const glyphCount = cluster.glyphs.length;
+                        if (this.clusterPositions.length < glyphCount) {
+                            for (let i = this.clusterPositions.length; i < glyphCount; i++) {
+                                this.clusterPositions.push(new Vec3(0, 0, 0));
+                            }
+                        }
+                        this.clusterPositions.length = glyphCount;
+                        for (let i = 0; i < glyphCount; i++) {
+                            const glyph = cluster.glyphs[i];
+                            const pos = this.clusterPositions[i];
+                            pos.x = glyph.x ?? 0;
+                            pos.y = glyph.y ?? 0;
+                            pos.z = 0;
+                        }
+                        boundaryGroups = this.clusterer.cluster(clusterGlyphContours, this.clusterPositions);
+                        this.clusteringCache.set(cacheKey, {
+                            glyphIds: cluster.glyphs.map((g) => g.g),
+                            positions: cluster.glyphs.map((g) => ({
+                                x: g.x ?? 0,
+                                y: g.y ?? 0
+                            })),
+                            groups: boundaryGroups
+                        });
+                    }
+                }
+                const forceSeparate = separateGlyphs;
+                // Split boundary groups so colored and non-colored glyphs don't merge together
+                // This preserves overlap removal within each color class while keeping
+                // geometry separate for accurate vertex coloring
+                let finalGroups = boundaryGroups;
+                if (coloredTextIndices && coloredTextIndices.size > 0) {
+                    finalGroups = [];
+                    for (const group of boundaryGroups) {
+                        if (group.length <= 1) {
+                            finalGroups.push(group);
+                        }
+                        else {
+                            // Split group into colored and non-colored sub-groups
+                            const coloredIndices = [];
+                            const nonColoredIndices = [];
+                            for (const idx of group) {
+                                const glyph = cluster.glyphs[idx];
+                                if (coloredTextIndices.has(glyph.absoluteTextIndex)) {
+                                    coloredIndices.push(idx);
+                                }
+                                else {
+                                    nonColoredIndices.push(idx);
+                                }
+                            }
+                            // Add non-empty sub-groups
+                            if (coloredIndices.length > 0) {
+                                finalGroups.push(coloredIndices);
+                            }
+                            if (nonColoredIndices.length > 0) {
+                                finalGroups.push(nonColoredIndices);
+                            }
+                        }
+                    }
+                }
+                // Iterate over the geometric groups identified by BoundaryClusterer
+                // logical groups (words) split into geometric sub-groups
+                for (const groupIndices of finalGroups) {
+                    const isOverlappingGroup = groupIndices.length > 1;
+                    const shouldCluster = isOverlappingGroup && !forceSeparate;
+                    if (shouldCluster) {
+                        // Cluster-level caching for this specific group of overlapping glyphs
+                        const subClusterGlyphs = groupIndices.map((i) => cluster.glyphs[i]);
+                        const clusterKey = this.getClusterKey(subClusterGlyphs, depth, removeOverlaps);
+                        let cachedCluster = this.wordCache.get(clusterKey);
+                        if (!cachedCluster) {
+                            const clusterContours = this.clusterContoursScratch;
+                            let contourIndex = 0;
+                            const refX = subClusterGlyphs[0].x ?? 0;
+                            const refY = subClusterGlyphs[0].y ?? 0;
+                            for (let i = 0; i < groupIndices.length; i++) {
+                                const originalIndex = groupIndices[i];
+                                const glyphContours = clusterGlyphContours[originalIndex];
+                                const glyph = cluster.glyphs[originalIndex];
+                                const relX = (glyph.x ?? 0) - refX;
+                                const relY = (glyph.y ?? 0) - refY;
+                                for (const path of glyphContours.paths) {
+                                    const points = path.points;
+                                    const pointCount = points.length;
+                                    if (pointCount < 3)
+                                        continue;
+                                    const isClosed = pointCount > 1 &&
+                                        points[0].x === points[pointCount - 1].x &&
+                                        points[0].y === points[pointCount - 1].y;
+                                    const end = isClosed ? pointCount - 1 : pointCount;
+                                    const needed = (end + 1) * 2;
+                                    let contour = clusterContours[contourIndex];
+                                    if (!contour || contour.length < needed) {
+                                        contour = new Array(needed);
+                                        clusterContours[contourIndex] = contour;
+                                    }
+                                    else {
+                                        contour.length = needed;
+                                    }
+                                    let out = 0;
+                                    for (let k = 0; k < end; k++) {
+                                        const pt = points[k];
+                                        contour[out++] = pt.x + relX;
+                                        contour[out++] = pt.y + relY;
+                                    }
+                                    if (out >= 2) {
+                                        contour[out++] = contour[0];
+                                        contour[out++] = contour[1];
+                                    }
+                                    contourIndex++;
+                                }
+                            }
+                            clusterContours.length = contourIndex;
+                            cachedCluster = this.tessellateGlyphCluster(clusterContours, depth, isCFF);
+                            this.wordCache.set(clusterKey, cachedCluster);
+                        }
+                        // Calculate the absolute position of this sub-cluster based on its first glyph
+                        // (since the cached geometry is relative to that first glyph)
+                        const firstGlyphInGroup = subClusterGlyphs[0];
+                        const groupPosX = clusterX + (firstGlyphInGroup.x ?? 0);
+                        const groupPosY = clusterY + (firstGlyphInGroup.y ?? 0);
+                        const groupPosZ = clusterZ;
+                        const vertexStart = pushTask(cachedCluster, groupPosX, groupPosY, groupPosZ);
+                        const clusterVertexCount = cachedCluster.vertices.length / 3;
+                        for (let i = 0; i < groupIndices.length; i++) {
+                            const originalIndex = groupIndices[i];
+                            const glyph = cluster.glyphs[originalIndex];
+                            const glyphContours = clusterGlyphContours[originalIndex];
+                            const glyphPosX = clusterX + (glyph.x ?? 0);
+                            const glyphPosY = clusterY + (glyph.y ?? 0);
+                            const glyphPosZ = clusterZ;
+                            const glyphInfo = this.createGlyphInfo(glyph, vertexStart, clusterVertexCount, glyphPosX, glyphPosY, glyphPosZ, glyphContours, depth);
+                            glyphInfos.push(glyphInfo);
+                            this.updatePlaneBounds(glyphInfo.bounds, planeBounds);
+                        }
+                    }
+                    else {
+                        // Glyph-level caching (standard path for isolated glyphs or when forced separate)
+                        for (const i of groupIndices) {
+                            const glyph = cluster.glyphs[i];
+                            const glyphContours = clusterGlyphContours[i];
+                            const glyphPosX = clusterX + (glyph.x ?? 0);
+                            const glyphPosY = clusterY + (glyph.y ?? 0);
+                            const glyphPosZ = clusterZ;
+                            // Skip glyphs with no paths (spaces, zero-width characters, etc.)
+                            if (glyphContours.paths.length === 0) {
+                                const glyphInfo = this.createGlyphInfo(glyph, 0, 0, glyphPosX, glyphPosY, glyphPosZ, glyphContours, depth);
+                                glyphInfos.push(glyphInfo);
+                                continue;
+                            }
+                            const glyphCacheKey = getGlyphCacheKey(this.cacheKeyPrefix, glyph.g, depth, removeOverlaps);
+                            let cachedGlyph = this.cache.get(glyphCacheKey);
+                            if (!cachedGlyph) {
+                                cachedGlyph = this.tessellateGlyph(glyphContours, depth, removeOverlaps, isCFF);
+                                this.cache.set(glyphCacheKey, cachedGlyph);
+                            }
+                            else {
+                                cachedGlyph.useCount++;
+                            }
+                            const vertexStart = pushTask(cachedGlyph, glyphPosX, glyphPosY, glyphPosZ);
+                            const glyphInfo = this.createGlyphInfo(glyph, vertexStart, cachedGlyph.vertices.length / 3, glyphPosX, glyphPosY, glyphPosZ, glyphContours, depth);
+                            glyphInfos.push(glyphInfo);
+                            this.updatePlaneBounds(glyphInfo.bounds, planeBounds);
+                        }
+                    }
+                }
+            }
+        }
+        tasks.length = taskCount;
+        const vertexArray = new Float32Array(totalVertexFloats);
+        const normalArray = new Float32Array(totalNormalFloats);
+        const indexArray = new Uint32Array(totalIndexCount);
+        let vertexPos = 0; // float index (multiple of 3)
+        let normalPos = 0; // float index (multiple of 3)
+        let indexPos = 0; // index count
+        for (let t = 0; t < tasks.length; t++) {
+            const task = tasks[t];
+            const v = task.data.vertices;
+            const n = task.data.normals;
+            const idx = task.data.indices;
+            const px = task.px;
+            const py = task.py;
+            const pz = task.pz;
+            const offsetX = px * scale;
+            const offsetY = py * scale;
+            const offsetZ = pz * scale;
+            const vLen = v.length;
+            let outPos = vertexPos;
+            for (let j = 0; j < vLen; j += 3) {
+                vertexArray[outPos] = v[j] * scale + offsetX;
+                vertexArray[outPos + 1] = v[j + 1] * scale + offsetY;
+                vertexArray[outPos + 2] = v[j + 2] * scale + offsetZ;
+                outPos += 3;
+            }
+            vertexPos = outPos;
+            normalArray.set(n, normalPos);
+            normalPos += n.length;
+            const vertexStart = task.vertexStart;
+            const idxLen = idx.length;
+            let outIndexPos = indexPos;
+            for (let j = 0; j < idxLen; j++) {
+                indexArray[outIndexPos++] = idx[j] + vertexStart;
+            }
+            indexPos = outIndexPos;
+        }
+        perfLogger.end('GlyphGeometryBuilder.buildInstancedGeometry');
+        planeBounds.min.x *= scale;
+        planeBounds.min.y *= scale;
+        planeBounds.min.z *= scale;
+        planeBounds.max.x *= scale;
+        planeBounds.max.y *= scale;
+        planeBounds.max.z *= scale;
+        for (let i = 0; i < glyphInfos.length; i++) {
+            glyphInfos[i].bounds.min.x *= scale;
+            glyphInfos[i].bounds.min.y *= scale;
+            glyphInfos[i].bounds.min.z *= scale;
+            glyphInfos[i].bounds.max.x *= scale;
+            glyphInfos[i].bounds.max.y *= scale;
+            glyphInfos[i].bounds.max.z *= scale;
+        }
+        return {
+            vertices: vertexArray,
+            normals: normalArray,
+            indices: indexArray,
+            glyphInfos,
+            planeBounds
+        };
+    }
+    getClusterKey(glyphs, depth, removeOverlaps) {
+        if (glyphs.length === 0)
+            return '';
+        const refX = glyphs[0].x ?? 0;
+        const refY = glyphs[0].y ?? 0;
+        const parts = glyphs.map((g) => {
+            const relX = (g.x ?? 0) - refX;
+            const relY = (g.y ?? 0) - refY;
+            return `${g.g}:${relX},${relY}`;
+        });
+        const ids = parts.join('|');
+        const roundedDepth = Math.round(depth * 1000) / 1000;
+        return `${this.cacheKeyPrefix}_${ids}_${roundedDepth}_${removeOverlaps}`;
+    }
+    createGlyphInfo(glyph, vertexStart, vertexCount, positionX, positionY, positionZ, contours, depth) {
+        return {
+            textIndex: glyph.absoluteTextIndex,
+            lineIndex: glyph.lineIndex,
+            vertexStart,
+            vertexCount,
+            bounds: {
+                min: {
+                    x: contours.bounds.min.x + positionX,
+                    y: contours.bounds.min.y + positionY,
+                    z: positionZ
+                },
+                max: {
+                    x: contours.bounds.max.x + positionX,
+                    y: contours.bounds.max.y + positionY,
+                    z: positionZ + depth
+                }
+            }
+        };
+    }
+    getContoursForGlyph(glyphId) {
+        // Fast path: skip HarfBuzz draw for known-empty glyphs (spaces, zero-width, etc)
+        if (this.emptyGlyphs.has(glyphId)) {
+            return {
+                glyphId,
+                paths: [],
+                bounds: {
+                    min: { x: 0, y: 0 },
+                    max: { x: 0, y: 0 }
+                }
+            };
+        }
+        const key = `${this.cacheKeyPrefix}_${glyphId}`;
+        const cached = this.contourCache.get(key);
+        if (cached) {
+            return cached;
+        }
+        // Rebind collector before draw operation
+        this.drawCallbacks.setCollector(this.collector);
+        this.collector.reset();
+        this.collector.beginGlyph(glyphId, 0);
+        this.loadedFont.module.exports.hb_font_draw_glyph(this.loadedFont.font.ptr, glyphId, this.drawCallbacks.getDrawFuncsPtr(), 0);
+        this.collector.finishGlyph();
+        const collected = this.collector.getCollectedGlyphs()[0];
+        const contours = collected || {
+            glyphId,
+            paths: [],
+            bounds: {
+                min: { x: 0, y: 0 },
+                max: { x: 0, y: 0 }
+            }
+        };
+        // Mark glyph as empty for future fast-path
+        if (contours.paths.length === 0) {
+            this.emptyGlyphs.add(glyphId);
+        }
+        this.contourCache.set(key, contours);
+        return contours;
+    }
+    tessellateGlyphCluster(contours, depth, isCFF) {
+        const processedGeometry = this.tessellator.processContours(contours, true, isCFF, depth !== 0);
+        return this.extrudeAndPackage(processedGeometry, depth);
+    }
+    extrudeAndPackage(processedGeometry, depth) {
+        perfLogger.start('Extruder.extrude', {
+            depth,
+            upem: this.loadedFont.upem
+        });
+        const extrudedResult = this.extruder.extrude(processedGeometry, depth, this.loadedFont.upem);
+        perfLogger.end('Extruder.extrude');
+        const vertices = extrudedResult.vertices;
+        let minX = Infinity, minY = Infinity, minZ = Infinity;
+        let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+        for (let i = 0; i < vertices.length; i += 3) {
+            const x = vertices[i];
+            const y = vertices[i + 1];
+            const z = vertices[i + 2];
+            if (x < minX)
+                minX = x;
+            if (x > maxX)
+                maxX = x;
+            if (y < minY)
+                minY = y;
+            if (y > maxY)
+                maxY = y;
+            if (z < minZ)
+                minZ = z;
+            if (z > maxZ)
+                maxZ = z;
+        }
+        const boundsMin = new Vec3(minX, minY, minZ);
+        const boundsMax = new Vec3(maxX, maxY, maxZ);
+        return {
+            geometry: processedGeometry,
+            vertices: extrudedResult.vertices,
+            normals: extrudedResult.normals,
+            indices: extrudedResult.indices,
+            bounds: { min: boundsMin, max: boundsMax },
+            useCount: 1
+        };
+    }
+    tessellateGlyph(glyphContours, depth, removeOverlaps, isCFF) {
+        perfLogger.start('GlyphGeometryBuilder.tessellateGlyph', {
+            glyphId: glyphContours.glyphId,
+            pathCount: glyphContours.paths.length
+        });
+        const processedGeometry = this.tessellator.process(glyphContours.paths, removeOverlaps, isCFF, depth !== 0);
+        perfLogger.end('GlyphGeometryBuilder.tessellateGlyph');
+        return this.extrudeAndPackage(processedGeometry, depth);
+    }
+    updatePlaneBounds(glyphBounds, planeBounds) {
+        const pMin = planeBounds.min;
+        const pMax = planeBounds.max;
+        const gMin = glyphBounds.min;
+        const gMax = glyphBounds.max;
+        if (gMin.x < pMin.x)
+            pMin.x = gMin.x;
+        if (gMin.y < pMin.y)
+            pMin.y = gMin.y;
+        if (gMin.z < pMin.z)
+            pMin.z = gMin.z;
+        if (gMax.x > pMax.x)
+            pMax.x = gMax.x;
+        if (gMax.y > pMax.y)
+            pMax.y = gMax.y;
+        if (gMax.z > pMax.z)
+            pMax.z = gMax.z;
+    }
+    getCacheStats() {
+        return this.cache.getStats();
+    }
+    clearCache() {
+        this.cache.clear();
+        this.wordCache.clear();
+        this.clusteringCache.clear();
+        this.contourCache.clear();
+    }
+}
+
+class MeshGeometryBuilder {
+    constructor(loadedFont, fontId) {
+        this.loadedFont = loadedFont;
+        this.fontId = fontId;
+    }
+    setFont(loadedFont, fontId) {
+        this.loadedFont = loadedFont;
+        this.fontId = fontId;
+        this.geometryBuilder = undefined;
+    }
+    build(layout, options) {
+        perfLogger.start('MeshGeometryBuilder.build', {
+            textLength: options.text.length
+        });
+        try {
+            if (!this.geometryBuilder) {
+                this.geometryBuilder = new GlyphGeometryBuilder(globalGlyphCache, this.loadedFont);
+                this.geometryBuilder.setFontId(this.fontId);
+            }
+            const useCurveSteps = options.curveSteps !== undefined &&
+                options.curveSteps !== null &&
+                options.curveSteps > 0;
+            this.geometryBuilder.setCurveSteps(options.curveSteps);
+            this.geometryBuilder.setCurveFidelityConfig(useCurveSteps ? undefined : options.curveFidelity);
+            this.geometryBuilder.setGeometryOptimization(options.geometryOptimization);
+            const shouldRemoveOverlaps = options.removeOverlaps ?? this.loadedFont.isVariable ?? false;
+            let coloredTextIndices;
+            let byTextMatches;
+            if (options.color &&
+                typeof options.color === 'object' &&
+                !Array.isArray(options.color)) {
+                if (options.color.byText || options.color.byCharRange) {
+                    coloredTextIndices = new Set();
+                    if (options.color.byText) {
+                        byTextMatches = [];
+                        for (const pattern of Object.keys(options.color.byText)) {
+                            let index = 0;
+                            while ((index = options.text.indexOf(pattern, index)) !== -1) {
+                                byTextMatches.push({
+                                    pattern,
+                                    start: index,
+                                    end: index + pattern.length
+                                });
+                                for (let i = index; i < index + pattern.length; i++) {
+                                    coloredTextIndices.add(i);
+                                }
+                                index += pattern.length;
+                            }
+                        }
+                    }
+                    if (options.color.byCharRange) {
+                        for (const range of options.color.byCharRange) {
+                            for (let i = range.start; i < range.end; i++) {
+                                coloredTextIndices.add(i);
+                            }
+                        }
+                    }
+                }
+            }
+            const shapedResult = this.geometryBuilder.buildInstancedGeometry(layout.clustersByLine, layout.layoutData.depth, shouldRemoveOverlaps, this.loadedFont.metrics.isCFF, layout.layoutData.pixelsPerFontUnit, options.perGlyphAttributes ?? false, coloredTextIndices);
+            const result = this.finalizeGeometry(shapedResult.vertices, shapedResult.normals, shapedResult.indices, shapedResult.glyphInfos, shapedResult.planeBounds, options, options.text, byTextMatches);
+            if (options.perGlyphAttributes) {
+                const glyphAttrs = this.createGlyphAttributes(result.vertices.length / 3, result.glyphs);
+                result.glyphAttributes = glyphAttrs;
+            }
+            return result;
+        }
+        finally {
+            perfLogger.end('MeshGeometryBuilder.build');
+        }
+    }
+    getCacheSize() {
+        return this.geometryBuilder?.getCacheStats().size ?? 0;
+    }
+    clearCache() {
+        this.geometryBuilder?.clearCache();
+    }
+    reset() {
+        this.geometryBuilder = undefined;
+        this.textLayout = undefined;
+    }
+    finalizeGeometry(vertices, normals, indices, glyphInfoArray, planeBounds, options, originalText, byTextMatches) {
+        const { layout = {} } = options;
+        const { width, align = layout.direction === 'rtl' ? 'right' : 'left' } = layout;
+        if (!this.textLayout) {
+            this.textLayout = new TextLayout(this.loadedFont);
+        }
+        const alignmentResult = this.textLayout.computeAlignmentOffset({
+            width,
+            align,
+            planeBounds
+        });
+        const offset = alignmentResult.offset;
+        planeBounds.min.x = alignmentResult.adjustedBounds.min.x;
+        planeBounds.max.x = alignmentResult.adjustedBounds.max.x;
+        if (offset !== 0) {
+            for (let i = 0; i < vertices.length; i += 3) {
+                vertices[i] += offset;
+            }
+            for (let i = 0; i < glyphInfoArray.length; i++) {
+                glyphInfoArray[i].bounds.min.x += offset;
+                glyphInfoArray[i].bounds.max.x += offset;
+            }
+        }
+        let colors;
+        let coloredRanges;
+        if (options.color) {
+            const colorResult = this.applyColorSystem(vertices, glyphInfoArray, options.color, options.text, byTextMatches);
+            colors = colorResult.colors;
+            coloredRanges = colorResult.coloredRanges;
+        }
+        const optimizationStats = this.geometryBuilder.getOptimizationStats();
+        const trianglesGenerated = indices.length / 3;
+        const verticesGenerated = vertices.length / 3;
+        return {
+            vertices,
+            normals,
+            indices,
+            colors,
+            glyphs: glyphInfoArray,
+            planeBounds,
+            stats: {
+                trianglesGenerated,
+                verticesGenerated,
+                pointsRemovedByVisvalingam: optimizationStats.pointsRemovedByVisvalingam,
+                originalPointCount: optimizationStats.originalPointCount
+            },
+            query: (() => {
+                let cachedQuery = null;
+                return (queryOptions) => {
+                    if (!originalText) {
+                        throw new Error('Original text not available for querying');
+                    }
+                    if (!cachedQuery) {
+                        cachedQuery = new TextRangeQuery(originalText, glyphInfoArray);
+                    }
+                    return cachedQuery.execute(queryOptions);
+                };
+            })(),
+            coloredRanges,
+            glyphAttributes: undefined
+        };
+    }
+    applyColorSystem(vertices, glyphInfoArray, color, originalText, byTextMatches) {
+        const vertexCount = vertices.length / 3;
+        const colors = new Float32Array(vertexCount * 3);
+        const coloredRanges = [];
+        if (Array.isArray(color)) {
+            for (let i = 0; i < vertexCount; i++) {
+                const baseIndex = i * 3;
+                colors[baseIndex] = color[0];
+                colors[baseIndex + 1] = color[1];
+                colors[baseIndex + 2] = color[2];
+            }
+            coloredRanges.push({
+                start: 0,
+                end: originalText.length,
+                originalText,
+                color,
+                bounds: [],
+                glyphs: glyphInfoArray,
+                lineIndices: [...new Set(glyphInfoArray.map((g) => g.lineIndex))]
+            });
+        }
+        else {
+            const defaultColor = color.default || [1, 1, 1];
+            for (let i = 0; i < colors.length; i += 3) {
+                colors[i] = defaultColor[0];
+                colors[i + 1] = defaultColor[1];
+                colors[i + 2] = defaultColor[2];
+            }
+            let glyphsByTextIndex;
+            if ((color.byText && byTextMatches) || color.byCharRange) {
+                glyphsByTextIndex = new Map();
+                for (const glyph of glyphInfoArray) {
+                    const existing = glyphsByTextIndex.get(glyph.textIndex);
+                    if (existing) {
+                        existing.push(glyph);
+                    }
+                    else {
+                        glyphsByTextIndex.set(glyph.textIndex, [glyph]);
+                    }
+                }
+            }
+            if (color.byText && byTextMatches && glyphsByTextIndex) {
+                for (const match of byTextMatches) {
+                    const targetColor = color.byText[match.pattern];
+                    if (!targetColor)
+                        continue;
+                    const matchGlyphs = [];
+                    const lineGroups = new Map();
+                    for (let i = match.start; i < match.end; i++) {
+                        const glyphs = glyphsByTextIndex.get(i);
+                        if (glyphs) {
+                            for (const glyph of glyphs) {
+                                matchGlyphs.push(glyph);
+                                const lineGlyphs = lineGroups.get(glyph.lineIndex);
+                                if (lineGlyphs) {
+                                    lineGlyphs.push(glyph);
+                                }
+                                else {
+                                    lineGroups.set(glyph.lineIndex, [glyph]);
+                                }
+                                for (let v = 0; v < glyph.vertexCount; v++) {
+                                    const vertexIndex = (glyph.vertexStart + v) * 3;
+                                    if (vertexIndex >= 0 && vertexIndex < colors.length) {
+                                        colors[vertexIndex] = targetColor[0];
+                                        colors[vertexIndex + 1] = targetColor[1];
+                                        colors[vertexIndex + 2] = targetColor[2];
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    const bounds = Array.from(lineGroups.values()).map((lineGlyphs) => this.calculateGlyphBounds(lineGlyphs));
+                    coloredRanges.push({
+                        start: match.start,
+                        end: match.end,
+                        originalText: match.pattern,
+                        color: targetColor,
+                        bounds,
+                        glyphs: matchGlyphs,
+                        lineIndices: Array.from(lineGroups.keys()).sort((a, b) => a - b)
+                    });
+                }
+            }
+            if (color.byCharRange && glyphsByTextIndex) {
+                for (const range of color.byCharRange) {
+                    const rangeGlyphs = [];
+                    const lineGroups = new Map();
+                    for (let i = range.start; i < range.end; i++) {
+                        const glyphs = glyphsByTextIndex.get(i);
+                        if (glyphs) {
+                            for (const glyph of glyphs) {
+                                rangeGlyphs.push(glyph);
+                                const lineGlyphs = lineGroups.get(glyph.lineIndex);
+                                if (lineGlyphs) {
+                                    lineGlyphs.push(glyph);
+                                }
+                                else {
+                                    lineGroups.set(glyph.lineIndex, [glyph]);
+                                }
+                                for (let v = 0; v < glyph.vertexCount; v++) {
+                                    const vertexIndex = (glyph.vertexStart + v) * 3;
+                                    if (vertexIndex >= 0 && vertexIndex < colors.length) {
+                                        colors[vertexIndex] = range.color[0];
+                                        colors[vertexIndex + 1] = range.color[1];
+                                        colors[vertexIndex + 2] = range.color[2];
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    const bounds = Array.from(lineGroups.values()).map((lineGlyphs) => this.calculateGlyphBounds(lineGlyphs));
+                    coloredRanges.push({
+                        start: range.start,
+                        end: range.end,
+                        originalText: originalText.slice(range.start, range.end),
+                        color: range.color,
+                        bounds,
+                        glyphs: rangeGlyphs,
+                        lineIndices: Array.from(lineGroups.keys()).sort((a, b) => a - b)
+                    });
+                }
+            }
+        }
+        return { colors, coloredRanges };
+    }
+    calculateGlyphBounds(glyphs) {
+        if (glyphs.length === 0) {
+            return {
+                min: { x: 0, y: 0, z: 0 },
+                max: { x: 0, y: 0, z: 0 }
+            };
+        }
+        let minX = Infinity, minY = Infinity, minZ = Infinity;
+        let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+        for (const glyph of glyphs) {
+            if (glyph.bounds.min.x < minX)
+                minX = glyph.bounds.min.x;
+            if (glyph.bounds.min.y < minY)
+                minY = glyph.bounds.min.y;
+            if (glyph.bounds.min.z < minZ)
+                minZ = glyph.bounds.min.z;
+            if (glyph.bounds.max.x > maxX)
+                maxX = glyph.bounds.max.x;
+            if (glyph.bounds.max.y > maxY)
+                maxY = glyph.bounds.max.y;
+            if (glyph.bounds.max.z > maxZ)
+                maxZ = glyph.bounds.max.z;
+        }
+        return {
+            min: { x: minX, y: minY, z: minZ },
+            max: { x: maxX, y: maxY, z: maxZ }
+        };
+    }
+    createGlyphAttributes(vertexCount, glyphs) {
+        const glyphCenters = new Float32Array(vertexCount * 3);
+        const glyphIndices = new Float32Array(vertexCount);
+        const glyphLineIndices = new Float32Array(vertexCount);
+        const glyphProgress = new Float32Array(vertexCount);
+        const glyphBaselineY = new Float32Array(vertexCount);
+        let minX = Infinity;
+        let maxX = -Infinity;
+        for (let i = 0; i < glyphs.length; i++) {
+            const cx = (glyphs[i].bounds.min.x + glyphs[i].bounds.max.x) / 2;
+            if (cx < minX)
+                minX = cx;
+            if (cx > maxX)
+                maxX = cx;
+        }
+        const range = maxX - minX;
+        for (let index = 0; index < glyphs.length; index++) {
+            const glyph = glyphs[index];
+            const centerX = (glyph.bounds.min.x + glyph.bounds.max.x) / 2;
+            const centerY = (glyph.bounds.min.y + glyph.bounds.max.y) / 2;
+            const centerZ = (glyph.bounds.min.z + glyph.bounds.max.z) / 2;
+            const baselineY = glyph.bounds.min.y;
+            const progress = range > 0 ? (centerX - minX) / range : 0;
+            const start = glyph.vertexStart;
+            const end = Math.min(start + glyph.vertexCount, vertexCount);
+            if (end <= start)
+                continue;
+            glyphIndices.fill(index, start, end);
+            glyphLineIndices.fill(glyph.lineIndex, start, end);
+            glyphProgress.fill(progress, start, end);
+            glyphBaselineY.fill(baselineY, start, end);
+            for (let v = start * 3; v < end * 3; v += 3) {
+                glyphCenters[v] = centerX;
+                glyphCenters[v + 1] = centerY;
+                glyphCenters[v + 2] = centerZ;
+            }
+        }
+        return {
+            glyphCenter: glyphCenters,
+            glyphIndex: glyphIndices,
+            glyphLineIndex: glyphLineIndices,
+            glyphProgress,
+            glyphBaselineY
+        };
+    }
+}
 
 // p5.js adapter
 function convertToP5Geometry(p5Instance, textGeometry) {
@@ -83,18 +2813,21 @@ if (typeof window !== 'undefined' && window.p5) {
         }
         const { font, ...coreOptions } = options;
         try {
-            const result = await Text.create({
+            const fullOptions = {
                 text,
                 font: font.buffer,
                 fontVariations: font.variations,
                 ...coreOptions
-            });
+            };
+            const layoutHandle = await Text.create(fullOptions);
+            const meshPipeline = new MeshGeometryBuilder(layoutHandle.loadedFont, layoutHandle.fontId);
+            const meshResult = meshPipeline.build(layoutHandle, fullOptions);
             const p5Instance = this;
-            const geometry = convertToP5Geometry(p5Instance, result);
+            const geometry = convertToP5Geometry(p5Instance, meshResult);
             return {
                 geometry,
-                planeBounds: result.planeBounds,
-                glyphs: result.glyphs
+                planeBounds: meshResult.planeBounds,
+                glyphs: meshResult.glyphs
             };
         }
         catch (err) {