@web-ppt/fonts 0.5.0-beta.1 → 0.5.0-beta.7

package/dist/glyphs/sfnt.d.ts

@@ -0,0 +1,10 @@
+import type { FontFaceInfo } from './types';
+export interface FontTable {
+    offset: number;
+    length: number;
+}
+export interface SfntFont {
+    tables: ReadonlyMap<string, FontTable>;
+    info: Omit<FontFaceInfo, 'id' | 'family' | 'origin'>;
+}
+export declare function inspectSfnt(bytes: Uint8Array): SfntFont;

package/dist/glyphs/shape-run.d.ts

@@ -0,0 +1,3 @@
+import type { FontFaceInfo, FontResult, FontShapeOptions, GlyphRun, ShaperGlyph } from './types';
+export declare function checkShapeText(text: string, options: FontShapeOptions, maxLength: number): void;
+export declare function makeGlyphRun(info: FontFaceInfo, text: string, options: FontShapeOptions, raw: ShaperGlyph[]): FontResult<GlyphRun>;

package/dist/glyphs/shaping.d.ts

@@ -0,0 +1,8 @@
+import type { FontEmbedding, FontProviderOptions, FontRequestOptions, FontResult, FontShapeOptions, GlyphRun } from './types';
+export declare function abortable<T>(pending: Promise<T>, signal: AbortSignal): Promise<T>;
+export declare function createShaping(options: FontProviderOptions, embedding: (id: string, options: FontRequestOptions) => Promise<FontResult<FontEmbedding>>): {
+    release(id: string): void;
+    shape(id: string, text: string, request: FontShapeOptions): Promise<FontResult<GlyphRun>>;
+    outline(id: string, glyphId: number, request: FontRequestOptions): Promise<FontResult<string>>;
+    dispose(): void;
+};

package/dist/glyphs/text-scripts.d.ts

@@ -0,0 +1,15 @@
+import type { FontResult, FontScript } from './types';
+export interface FontTextSegment {
+    start: number;
+    end: number;
+    text: string;
+    script: FontScript;
+    direction: 'ltr';
+    language: string;
+}
+export declare function fontCharacterScript(character: string, start: number): FontScript | undefined;
+/** 此处只分脚本；沿用输入原文，断行和字体选择仍由已有布局及宿主负责。 */
+export declare function segmentFontText(text: string, options: {
+    direction: 'ltr';
+    language: string;
+}): FontResult<FontTextSegment[]>;

package/dist/glyphs/types.d.ts

@@ -0,0 +1,126 @@
+export interface FontSource {
+    id: string;
+    family?: string;
+    bytes?: Uint8Array;
+    origin: 'explicit' | 'embedded' | 'substitute';
+    sourceLabel?: string;
+    embeddingEvidence?: string;
+    /** 上游容器或使用许可施加的额外限制，只能收紧 sfnt 自身权限。 */
+    restrictions?: FontEmbeddingRights;
+}
+export interface FontRequestOptions {
+    purpose: 'edit' | 'view-print';
+    signal?: AbortSignal;
+}
+export interface FontRequest extends FontRequestOptions {
+    family: string;
+    weight: number;
+    italic: boolean;
+}
+export interface FontFaceInfo {
+    id: string;
+    family: string;
+    sourceFamily: string;
+    weight: number;
+    italic: boolean;
+    format: 'ttf-glyf';
+    unitsPerEm: number;
+    glyphCount: number;
+    bbox: readonly [number, number, number, number];
+    fsType: number;
+    os2Version: number;
+    byteLength: number;
+    origin: FontSource['origin'];
+    sourceLabel?: string;
+    embeddingEvidence?: string;
+    embedding: FontEmbeddingRights;
+}
+export interface FontEmbeddingRights {
+    usage: 'installable' | 'editable' | 'view-print' | 'restricted';
+    subsetAllowed: boolean;
+    outlineAllowed: boolean;
+}
+export interface FontEmbedding {
+    bytes: Uint8Array;
+    info: FontFaceInfo;
+}
+export type FontScript = 'Latn' | 'Hani';
+export interface FontShapeOptions extends FontRequestOptions {
+    script: FontScript;
+    direction: 'ltr';
+    language: string;
+}
+export interface PositionedGlyph {
+    id: number;
+    xAdvance: number;
+    yAdvance: number;
+    xOffset: number;
+    yOffset: number;
+}
+export interface GlyphCluster {
+    /** 原文 UTF-16 区间；字形编号与原文不可互相替代。 */
+    start: number;
+    end: number;
+    text: string;
+    glyphStart: number;
+    glyphEnd: number;
+}
+export interface GlyphRun {
+    faceId: string;
+    text: string;
+    script: FontScript;
+    direction: 'ltr';
+    language: string;
+    unitsPerEm: number;
+    xAdvance: number;
+    yAdvance: number;
+    glyphs: PositionedGlyph[];
+    clusters: GlyphCluster[];
+}
+/** 适配器边界只使用设计单位和 UTF-16 簇，不暴露第三方字体对象。 */
+export interface ShaperGlyph extends PositionedGlyph {
+    cluster: number;
+}
+export interface FontShaperFace {
+    shape(text: string, options: FontShapeOptions): Promise<ShaperGlyph[]>;
+    outline(glyphId: number, options: FontRequestOptions): Promise<string>;
+    dispose(): void;
+}
+export interface FontShaper {
+    open(font: FontEmbedding, signal: AbortSignal): Promise<FontShaperFace>;
+    dispose(): void;
+}
+export interface FontProviderOptions {
+    loadShaper?: (signal: AbortSignal) => Promise<FontShaper>;
+    limits?: Partial<FontProviderLimits>;
+    decodeEot?: (bytes: Uint8Array, options: {
+        signal: AbortSignal;
+        maxOutputBytes: number;
+    }) => Promise<Uint8Array | null>;
+}
+export interface FontProviderLimits {
+    maxFontBytes: number;
+    maxTotalFontBytes: number;
+    maxFaces: number;
+    maxGlyphs: number;
+    maxTextLength: number;
+}
+export type FontProblem = 'font-bytes-unavailable' | 'provider-disposed' | 'invalid-font' | 'aborted' | 'face-unavailable' | 'duplicate-face-id' | 'ambiguous-face' | 'resource-limit' | 'embedding-restricted' | 'preview-print-only' | 'bitmap-only' | 'cmap-not-supported' | 'missing-glyphs' | 'unsupported-script' | 'unsupported-direction' | 'script-mismatch' | 'invalid-text' | 'shaper-unavailable' | 'shaper-failed' | 'invalid-glyph-id' | 'invalid-request' | 'needs-container-decoder' | 'collection-not-supported' | 'variable-not-supported' | 'cff-not-supported' | 'color-font-not-supported' | 'decoder-unavailable' | 'decode-failed' | 'eot-root-restricted' | 'eot-feature-not-supported' | 'subset-not-permitted' | 'measurement-not-prepared' | 'unsupported-layout' | 'layout-failed' | 'face-style-mismatch' | 'font-install-failed';
+export interface FontFailure {
+    ok: false;
+    reason: FontProblem;
+    faceId?: string;
+    missing?: Array<{
+        start: number;
+        end: number;
+        text: string;
+    }>;
+    range?: {
+        start: number;
+        end: number;
+    };
+}
+export type FontResult<T> = {
+    ok: true;
+    value: T;
+} | FontFailure;

package/dist/glyphs/validate-cmap.d.ts

@@ -0,0 +1,4 @@
+import type { SfntFont } from './sfnt';
+import type { FontValidationPause } from './validation-budget';
+/** 只验证字符映射范围；实际选字仍交给整形器，避免两套 cmap 选择规则。 */
+export declare function validateCmap(bytes: Uint8Array, font: SfntFont, pause: FontValidationPause): Promise<void>;

package/dist/glyphs/validate-glyphs.d.ts

@@ -0,0 +1,3 @@
+import type { SfntFont } from './sfnt';
+import type { FontValidationPause } from './validation-budget';
+export declare function validateGlyphStorage(bytes: Uint8Array, font: SfntFont, pause: FontValidationPause): Promise<void>;

package/dist/glyphs/validation-budget.d.ts

@@ -0,0 +1,5 @@
+import type { FontProviderLimits } from './types';
+export type FontValidationPause = () => Promise<void> | undefined;
+export declare function fontLimits(input?: Partial<FontProviderLimits>): FontProviderLimits;
+/** 让长校验归还事件循环，AbortSignal 才有机会在注册提交之前生效。 */
+export declare function validationPause(check: () => void): FontValidationPause;

package/dist/glyphs/worker-client.d.ts

@@ -0,0 +1,18 @@
+import type { FontProviderOptions, FontShaper } from './types';
+import type { FontWorker } from './worker-protocol';
+export interface FontWorkerOptions {
+    maxQueuedRequests?: number;
+    maxPendingBytes?: number;
+    requestTimeoutMs?: number;
+}
+/** 活跃请求取消时结束整个 WASM 实例；未取消请求在新 Worker 按需重建字体。 */
+export declare function createWorkerFontShaper(factory: () => FontWorker, options?: FontWorkerOptions): FontShaper & {
+    decodeEot: NonNullable<FontProviderOptions['decodeEot']>;
+    state(): {
+        disposed: boolean;
+        retainedFontBytes: number;
+        pendingRequests: number;
+        pendingBytes: number;
+        workerActive: boolean;
+    };
+};

package/dist/glyphs/worker-protocol.d.ts

@@ -0,0 +1,35 @@
+import type { FontFaceInfo, FontResult, FontShapeOptions, GlyphRun } from './types';
+export declare const FONT_WORKER_PROTOCOL = "web-ppt-fonts/1";
+export type FontWorkerRequest = {
+    protocol: typeof FONT_WORKER_PROTOCOL;
+    id: number;
+} & ({
+    operation: 'register';
+    face: FontFaceInfo;
+    bytes: Uint8Array;
+} | {
+    operation: 'shape';
+    faceId: string;
+    text: string;
+    options: Omit<FontShapeOptions, 'signal'>;
+} | {
+    operation: 'outline';
+    faceId: string;
+    glyphId: number;
+    purpose: 'edit' | 'view-print';
+} | {
+    operation: 'decode';
+    bytes: Uint8Array;
+    maxOutputBytes: number;
+});
+export interface FontWorkerResponse {
+    protocol: typeof FONT_WORKER_PROTOCOL;
+    id: number;
+    result: FontResult<FontFaceInfo | GlyphRun | string | Uint8Array>;
+}
+export interface FontWorkerEndpoint {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+    removeEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+}
+export type FontWorker = Pick<Worker, 'postMessage' | 'addEventListener' | 'removeEventListener' | 'terminate'>;

package/dist/glyphs/worker-result.d.ts

@@ -0,0 +1,3 @@
+import type { FontFaceInfo, FontShapeOptions, ShaperGlyph } from './types';
+/** Worker 也是输入边界；先限制簇范围，再展开，避免错误消息造成无限循环或大分配。 */
+export declare function workerGlyphs(value: unknown, info: FontFaceInfo, text: string, options: FontShapeOptions): ShaperGlyph[];

package/dist/glyphs/worker-server.d.ts

@@ -0,0 +1,4 @@
+import type { FontProviderOptions } from './types';
+import type { FontWorkerEndpoint } from './worker-protocol';
+/** 在专属 Worker 内安装；入口及 WASM URL 由宿主构建工具决定。 */
+export declare function serveFontWorker(endpoint: FontWorkerEndpoint, options: FontProviderOptions): () => void;

package/dist/glyphs/worker.d.ts

@@ -0,0 +1,4 @@
+export { serveFontWorker } from './worker-server';
+export { createWorkerFontShaper } from './worker-client';
+export type { FontWorkerOptions } from './worker-client';
+export type { FontWorker, FontWorkerEndpoint } from './worker-protocol';

package/dist/glyphs-browser.js

@@ -0,0 +1,78 @@
+function U(b, a, t) {
+  return new Promise((f, u) => {
+    const n = () => {
+      o(), u(new DOMException("字体加载已取消", "AbortError"));
+    }, o = () => {
+      a.removeEventListener("abort", n), t == null || t.removeEventListener("abort", n);
+    };
+    if (a.addEventListener("abort", n, { once: !0 }), t == null || t.addEventListener("abort", n, { once: !0 }), a.aborted || t != null && t.aborted) {
+      o(), n();
+      return;
+    }
+    Promise.resolve().then(() => b.load()).then(() => {
+      o(), f();
+    }, (e) => {
+      o(), u(e);
+    });
+  });
+}
+function p(b, a = document) {
+  const t = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Set(), u = new AbortController();
+  let n = !1;
+  const o = (e, r) => {
+    var s;
+    return n || b.state().disposed ? { ok: !1, reason: "provider-disposed", faceId: e } : (s = r.signal) != null && s.aborted ? { ok: !1, reason: "aborted", faceId: e } : void 0;
+  };
+  return {
+    async install(e, r) {
+      const s = o(e, r);
+      if (s) return s;
+      const y = await b.embedding(e, r);
+      if (!y.ok) return y;
+      const g = o(e, r);
+      if (g) return g;
+      const { info: i, bytes: m } = y.value, l = r.family ?? i.family;
+      if (![400, 700].includes(i.weight)) return { ok: !1, reason: "face-style-mismatch", faceId: e };
+      if (!l.trim() || l.length > 256 || /[\u0000-\u001f\u007f]/.test(l)) return { ok: !1, reason: "invalid-request", faceId: e };
+      const d = JSON.stringify([e, l]), k = t.get(d);
+      if (k) return { ok: !0, value: { ...k.resource } };
+      if (f.has(d)) return { ok: !1, reason: "duplicate-face-id", faceId: e };
+      f.add(d);
+      let c, v;
+      try {
+        const L = o(e, r);
+        if (L) return L;
+        c = new FontFace(l, new Uint8Array(m).buffer, { weight: String(i.weight), style: i.italic ? "italic" : "normal" }), await U(c, u.signal, r.signal);
+        const w = o(e, r);
+        if (w) return w;
+        a.fonts.add(c), v = URL.createObjectURL(new Blob([new Uint8Array(m).buffer], { type: "font/ttf" }));
+        const h = { family: l, src: v, bold: i.weight === 700, italic: i.italic };
+        return t.set(d, { id: e, font: c, resource: h, bytes: m.length }), { ok: !0, value: { ...h } };
+      } catch {
+        return c && a.fonts.delete(c), v && URL.revokeObjectURL(v), o(e, r) ?? { ok: !1, reason: "font-install-failed", faceId: e };
+      } finally {
+        f.delete(d);
+      }
+    },
+    resources() {
+      return [...t.values()].map((e) => ({ ...e.resource }));
+    },
+    remove(e) {
+      for (const [r, s] of t) s.id === e && (a.fonts.delete(s.font), URL.revokeObjectURL(s.resource.src), t.delete(r));
+    },
+    state() {
+      return { disposed: n, faces: t.size, sourceBytes: [...t.values()].reduce((e, r) => e + r.bytes, 0) };
+    },
+    dispose() {
+      if (!n) {
+        n = !0, u.abort();
+        for (const e of t.values())
+          a.fonts.delete(e.font), URL.revokeObjectURL(e.resource.src);
+        t.clear();
+      }
+    }
+  };
+}
+export {
+  p as createFontFaceScope
+};

package/dist/glyphs-harfbuzz.js

@@ -0,0 +1,38 @@
+import { F as s } from "./fault-HMYM9DhC.js";
+function y(t) {
+  let r = !1;
+  const a = /* @__PURE__ */ new Set();
+  return {
+    async open(i, g) {
+      if (r || g.aborted) throw new s("aborted");
+      let n = new t.Font(new t.Face(new t.Blob(i.bytes)));
+      const c = () => {
+        n = void 0, a.delete(c);
+      };
+      return a.add(c), {
+        async shape(l, o) {
+          var f;
+          if (!n || r || (f = o.signal) != null && f.aborted) throw new s("aborted");
+          const e = new t.Buffer();
+          e.addText(l), e.guessSegmentProperties(), e.setDirection(t.Direction.LTR), e.setScript(o.script), e.setLanguage(o.language), t.shape(n, e);
+          const d = e.getGlyphInfos(), p = e.getGlyphPositions();
+          if (d.length !== p.length) throw new s("shaper-failed");
+          return d.map((u, w) => ({ id: u.codepoint, cluster: u.cluster, ...p[w] }));
+        },
+        async outline(l, o) {
+          var e;
+          if (!n || r || (e = o.signal) != null && e.aborted) throw new s("aborted");
+          return n.glyphToPath(l);
+        },
+        dispose: c
+      };
+    },
+    dispose() {
+      r = !0;
+      for (const i of [...a]) i();
+    }
+  };
+}
+export {
+  y as createHarfBuzzShaper
+};

package/dist/glyphs-worker.js

@@ -0,0 +1,215 @@
+import { c as W, f as C, m as G } from "./provider-9-K8y5p4.js";
+import { F as l } from "./fault-HMYM9DhC.js";
+const B = "web-ppt-fonts/1";
+function z(w, y) {
+  const u = W(y), h = new AbortController(), g = C(y.limits);
+  let i = !1, d = Promise.resolve();
+  const m = (v) => {
+    const s = v.data;
+    i || !s || s.protocol !== B || !Number.isSafeInteger(s.id) || (d = d.then(async () => {
+      if (i) return;
+      let t;
+      try {
+        if (s.operation === "register") t = await u.register({
+          id: s.face.id,
+          family: s.face.family,
+          origin: s.face.origin,
+          bytes: s.bytes,
+          restrictions: s.face.embedding
+        }, { purpose: "view-print" });
+        else if (s.operation === "shape") t = await u.shape(s.faceId, s.text, s.options);
+        else if (s.operation === "outline") t = await u.outline(s.faceId, s.glyphId, { purpose: s.purpose });
+        else if (s.operation === "decode")
+          if (!y.decodeEot) t = { ok: !1, reason: "decoder-unavailable" };
+          else if (!(s.bytes instanceof Uint8Array) || s.bytes.length > g.maxFontBytes || !Number.isSafeInteger(s.maxOutputBytes) || s.maxOutputBytes < 1) t = { ok: !1, reason: "resource-limit" };
+          else {
+            const a = Math.min(s.maxOutputBytes, g.maxFontBytes), r = await y.decodeEot(s.bytes, { signal: h.signal, maxOutputBytes: a });
+            t = r != null && r.length ? r.length > a ? { ok: !1, reason: "resource-limit" } : { ok: !0, value: new Uint8Array(r) } : { ok: !1, reason: "decode-failed" };
+          }
+        else t = { ok: !1, reason: "shaper-failed" };
+      } catch (a) {
+        t = { ok: !1, reason: a instanceof l ? a.reason : s.operation === "decode" ? "decode-failed" : "shaper-failed" };
+      }
+      i || w.postMessage(
+        { protocol: B, id: s.id, result: t },
+        t.ok && t.value instanceof Uint8Array ? [t.value.buffer] : []
+      );
+    }).catch(() => {
+    }));
+  };
+  return w.addEventListener("message", m), () => {
+    i || (i = !0, h.abort(), w.removeEventListener("message", m), u.dispose());
+  };
+}
+function _(w, y, u, h) {
+  const g = () => {
+    throw new l("shaper-failed");
+  };
+  (!w || typeof w != "object") && g();
+  const i = w;
+  if ((!Array.isArray(i.glyphs) || !Array.isArray(i.clusters) || i.faceId !== y.id || i.text !== u || i.unitsPerEm !== y.unitsPerEm || i.script !== h.script || i.direction !== h.direction || i.language !== h.language) && g(), i.glyphs.length > Math.max(256, u.length * 32) || i.clusters.length > i.glyphs.length)
+    throw new l("resource-limit");
+  const d = [];
+  let m = 0, v = 0;
+  for (const t of i.clusters) {
+    (!t || !Number.isInteger(t.glyphEnd) || !Number.isInteger(t.end) || t.glyphStart !== m || t.glyphEnd <= m || t.glyphEnd > i.glyphs.length || t.start !== v || t.end <= v || t.end > u.length || t.text !== u.slice(t.start, t.end)) && g();
+    for (let a = t.glyphStart; a < t.glyphEnd; a++) {
+      const r = i.glyphs[a];
+      (!r || typeof r != "object") && g(), d.push({ ...r, cluster: t.start });
+    }
+    m = t.glyphEnd, v = t.end;
+  }
+  (m !== i.glyphs.length || v !== u.length) && g();
+  const s = G(y, u, h, d);
+  return (!s.ok || s.value.xAdvance !== i.xAdvance || s.value.yAdvance !== i.yAdvance) && g(), d;
+}
+function D(w, y = {}) {
+  const u = y.maxQueuedRequests ?? 64, h = y.requestTimeoutMs ?? 3e4, g = y.maxPendingBytes ?? 64 * 1024 * 1024;
+  if (!Number.isInteger(u) || u < 1 || !Number.isSafeInteger(g) || g < 1 || !Number.isFinite(h) || h < 1) throw new RangeError("Invalid font worker budget");
+  const i = /* @__PURE__ */ new Map(), d = [], m = /* @__PURE__ */ new Set(), v = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+  let t = !1, a, r, R = 0, S = 0, L = 0, M = "action", k, A;
+  const O = () => {
+    k !== void 0 && clearTimeout(k), k = void 0, A == null || A(), A = void 0, a == null || a.terminate(), a = void 0, m.clear();
+  }, b = (e, o, n) => {
+    var E;
+    L -= e.cost, (E = e.signal) == null || E.removeEventListener("abort", e.cancel), e === r && (k !== void 0 && clearTimeout(k), k = void 0, r = void 0), n ? e.reject(n) : e.resolve(o);
+  }, I = () => {
+    O(), r && b(r, void 0, new l("shaper-failed"));
+    for (const e of d.splice(0)) b(e, void 0, new l("shaper-failed"));
+  }, q = () => {
+    if (!r || !a) return;
+    const e = r.font;
+    M = !e || m.has(e.info.id) ? "action" : "register", S = ++R;
+    const o = { protocol: B, id: S };
+    if (M === "register" && e) {
+      const n = e.bytes.slice();
+      a.postMessage({ ...o, operation: "register", face: e.info, bytes: n }, [n.buffer]);
+    } else if (r.action.operation === "decode") {
+      const n = r.action.bytes.slice();
+      a.postMessage({ ...o, ...r.action, bytes: n }, [n.buffer]);
+    } else e && a.postMessage({ ...o, ...r.action, faceId: e.info.id });
+  }, F = () => {
+    if (!(r || t || !d.length)) {
+      r = d.shift();
+      try {
+        if (!a) {
+          const e = w();
+          a = e;
+          const o = (E) => {
+            if (a !== e || !r) return;
+            const c = E.data;
+            if (!(!c || c.protocol !== B || c.id !== S)) {
+              if (!c.result || typeof c.result.ok != "boolean") {
+                I();
+                return;
+              }
+              if (!c.result.ok) {
+                b(r, void 0, new l(c.result.reason, c.result.missing, c.result.range)), F();
+                return;
+              }
+              if (M === "register") {
+                m.add(r.font.info.id);
+                try {
+                  q();
+                } catch {
+                  I();
+                }
+              } else
+                b(r, c.result.value), F();
+            }
+          }, n = () => {
+            a === e && I();
+          };
+          e.addEventListener("message", o), e.addEventListener("error", n), e.addEventListener("messageerror", n), A = () => {
+            e.removeEventListener("message", o), e.removeEventListener("error", n), e.removeEventListener("messageerror", n);
+          };
+        }
+        k = setTimeout(I, h), q();
+      } catch {
+        I();
+      }
+    }
+  }, N = (e, o, n) => new Promise((E, c) => {
+    if (t) {
+      c(new l("provider-disposed"));
+      return;
+    }
+    if (n != null && n.aborted) {
+      c(new l("aborted"));
+      return;
+    }
+    const x = o.operation === "decode" ? o.bytes.length : o.operation === "shape" ? o.text.length * 2 : 0;
+    if (d.length + (r ? 1 : 0) >= u || L + x > g) {
+      c(new l("resource-limit"));
+      return;
+    }
+    o.operation === "decode" && (o = { ...o, bytes: new Uint8Array(o.bytes) }), L += x;
+    const p = { font: e, action: o, cost: x, signal: n, resolve: E, reject: c, cancel: () => {
+      if (r === p)
+        O(), b(p, void 0, new l("aborted"));
+      else {
+        const f = d.indexOf(p);
+        if (f < 0) return;
+        d.splice(f, 1), b(p, void 0, new l("aborted"));
+      }
+      F();
+    } };
+    n == null || n.addEventListener("abort", p.cancel, { once: !0 }), d.push(p), F();
+  });
+  return {
+    async decodeEot(e, o) {
+      return await N(void 0, { operation: "decode", bytes: e, maxOutputBytes: o.maxOutputBytes }, o.signal);
+    },
+    async open(e, o) {
+      if (t || o.aborted) throw new l(t ? "provider-disposed" : "aborted");
+      if (v.has(e.info.id)) throw new l("duplicate-face-id");
+      v.add(e.info.id);
+      let n = { info: { ...e.info, bbox: [...e.info.bbox], embedding: { ...e.info.embedding } }, bytes: new Uint8Array(e.bytes) };
+      i.set(n.info.id, n);
+      const E = n.info.id, c = () => {
+        if (!n) return;
+        const p = n;
+        if (n = void 0, i.delete(E), s.delete(c), !t) {
+          for (let f = d.length - 1; f >= 0; f--) d[f].font === p && b(d.splice(f, 1)[0], void 0, new l("face-unavailable"));
+          (r == null ? void 0 : r.font) === p ? b(r, void 0, new l("face-unavailable")) : r && (d.unshift(r), r = void 0), O(), F();
+        }
+      };
+      s.add(c);
+      const x = () => {
+        if (!n || t) throw new l("provider-disposed");
+        return n;
+      };
+      return {
+        async shape(p, f) {
+          const P = x(), T = { purpose: f.purpose, script: f.script, direction: f.direction, language: f.language }, U = await N(P, { operation: "shape", text: p, options: T }, f.signal);
+          return _(U, P.info, p, f);
+        },
+        async outline(p, f) {
+          return await N(x(), { operation: "outline", glyphId: p, purpose: f.purpose }, f.signal);
+        },
+        dispose: c
+      };
+    },
+    state() {
+      return {
+        disposed: t,
+        retainedFontBytes: [...i.values()].reduce((e, o) => e + o.bytes.length, 0),
+        pendingRequests: d.length + (r ? 1 : 0),
+        pendingBytes: L,
+        workerActive: !!a
+      };
+    },
+    dispose() {
+      if (!t) {
+        t = !0, O(), r && b(r, void 0, new l("provider-disposed"));
+        for (const e of d.splice(0)) b(e, void 0, new l("provider-disposed"));
+        for (const e of [...s]) e();
+        i.clear(), v.clear();
+      }
+    }
+  };
+}
+export {
+  D as createWorkerFontShaper,
+  z as serveFontWorker
+};

package/dist/glyphs.js

@@ -0,0 +1,71 @@
+import { s as I } from "./provider-9-K8y5p4.js";
+import { c as P } from "./provider-9-K8y5p4.js";
+import { F as u } from "./fault-HMYM9DhC.js";
+async function x(g, z, a) {
+  var F;
+  const d = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Set(), w = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), m = a.maxQueries ?? 8192;
+  let h = !1, b = 0;
+  const v = (e, t, p) => {
+    var i;
+    if (!e) return 0;
+    if ((i = t.math) != null && i.length) throw new u("unsupported-layout");
+    const s = JSON.stringify([e, t.fonts, !!t.b, !!t.i]), o = d.get(s), l = t.size * p * (t.baseline ? 0.65 : 1);
+    if (o !== void 0) return o * l + (t.spacing ?? 0) * e.length;
+    if (!h) throw new u("measurement-not-prepared");
+    if (!n.has(s)) {
+      if (b += e.length, d.size + n.size >= m || b > 1e6) throw new u("resource-limit");
+      n.set(s, { text: e, style: { fonts: [...t.fonts], b: t.b, i: t.i } });
+    }
+    return e.length * l;
+  };
+  try {
+    if (!Number.isSafeInteger(m) || m < 1) return { ok: !1, reason: "invalid-request" };
+    for (let e = 0; e < 8; e++) {
+      if (g.state().disposed) return { ok: !1, reason: "provider-disposed" };
+      if ((F = a.signal) != null && F.aborted) return { ok: !1, reason: "aborted" };
+      n.clear(), h = !0;
+      let t;
+      try {
+        t = z(v);
+      } finally {
+        h = !1;
+      }
+      if (!n.size) return { ok: !0, value: { result: t, measureText: v, faceIds: [...k] } };
+      for (const [p, s] of n) {
+        const o = I(s.text, { direction: "ltr", language: a.language });
+        if (!o.ok) return o;
+        let l = 0;
+        for (const i of o.value) {
+          const r = a.faceForRun(s.style, i.script);
+          if (!r) return { ok: !1, reason: "face-unavailable" };
+          let f = w.get(r);
+          if (!f) {
+            const y = await g.faceInfo(r, a);
+            if (!y.ok) return y;
+            f = y.value, w.set(r, f);
+          }
+          if (f.weight !== (s.style.b ? 700 : 400) || f.italic !== !!s.style.i)
+            return { ok: !1, reason: "face-style-mismatch", faceId: r };
+          const c = await g.shape(r, i.text, {
+            purpose: a.purpose,
+            signal: a.signal,
+            language: a.language,
+            script: i.script,
+            direction: "ltr"
+          });
+          if (!c.ok) return c;
+          l += c.value.xAdvance / c.value.unitsPerEm, k.add(r);
+        }
+        d.set(p, l);
+      }
+    }
+    return { ok: !1, reason: "resource-limit" };
+  } catch (e) {
+    return e instanceof u ? { ok: !1, reason: e.reason, range: e.range } : { ok: !1, reason: "layout-failed" };
+  }
+}
+export {
+  P as createFontProvider,
+  I as segmentFontText,
+  x as withFontMeasurement
+};