@shadow-garden/bapbong-measuring 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Le Phuoc Minh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# @shadow-garden/bapbong-measuring
+
+Text measurement + font-metrics, behind a small injectable interface. The layout
+engine and selection math never touch the canvas directly — they call a
+`MeasureText` / `MeasureMetrics` provided by this package, so they stay testable
+in a headless (no-DOM) environment.
+
+- **Scope:** `scope:measuring`
+- **Depends on:** `@shadow-garden/bapbong-contracts`
+
+## What it provides
+
+- **`createCanvasMeasurer()` / `createCanvasMetrics()`** — real measurement via a
+  shared offscreen `CanvasRenderingContext2D` (`ctx.measureText`,
+  ascent/descent), with a per-font cache.
+- **`createApproxMeasurer()` / `createApproxMetrics()`** — DOM-free approximations
+  (average advance widths) for unit tests and SSR.
+- **`fontToCss(spec)`** — `FontSpec` → CSS `font` shorthand.
+
+## Build / test
+
+```sh
+pnpm nx build @shadow-garden/bapbong-measuring
+pnpm nx test  @shadow-garden/bapbong-measuring
+```

package/dist/index.cjs

@@ -0,0 +1,184 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/measuring/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FontRegistry: () => FontRegistry,
+  createApproxMeasurer: () => createApproxMeasurer,
+  createApproxMetrics: () => createApproxMetrics,
+  createCanvasMeasurer: () => createCanvasMeasurer,
+  createCanvasMetrics: () => createCanvasMetrics,
+  createFontRegistryMeasurer: () => createFontRegistryMeasurer,
+  createFontRegistryMetrics: () => createFontRegistryMetrics,
+  ensureFontsLoaded: () => ensureFontsLoaded,
+  fontToCss: () => fontToCss
+});
+module.exports = __toCommonJS(index_exports);
+
+// packages/measuring/src/lib/measuring.ts
+var PT_TO_PX = 96 / 72;
+function fontToCss(font) {
+  const style = font.italic ? "italic " : "";
+  const weight = font.bold ? "700 " : "400 ";
+  return `${style}${weight}${font.sizePt}pt ${font.family}`;
+}
+function createCanvasMeasurer() {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("bapbong-measuring: 2D canvas context unavailable");
+  return (text, font) => {
+    ctx.font = fontToCss(font);
+    return ctx.measureText(text).width;
+  };
+}
+function createApproxMeasurer(factor = 0.5) {
+  return (text, font) => text.length * font.sizePt * factor;
+}
+function createCanvasMetrics() {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("bapbong-measuring: 2D canvas context unavailable");
+  return (font) => {
+    ctx.font = fontToCss(font);
+    const m = ctx.measureText("Mg");
+    const ascent = m.fontBoundingBoxAscent ?? m.actualBoundingBoxAscent;
+    const descent = m.fontBoundingBoxDescent ?? m.actualBoundingBoxDescent;
+    return { ascent, descent };
+  };
+}
+function createApproxMetrics() {
+  return (font) => {
+    const em = font.sizePt * PT_TO_PX;
+    return { ascent: em * 0.8, descent: em * 0.2 };
+  };
+}
+async function ensureFontsLoaded(families, sizePt = 12) {
+  const fonts = globalThis.document?.fonts;
+  if (!fonts?.load) return;
+  const variants = ["", "italic ", "700 ", "italic 700 "];
+  const loads = [];
+  for (const family of new Set(families)) {
+    for (const variant of variants) {
+      loads.push(fonts.load(`${variant}${sizePt}pt "${family}"`).catch(() => []));
+    }
+  }
+  await Promise.all(loads);
+}
+
+// packages/measuring/src/lib/font-registry.ts
+var opentype = __toESM(require("opentype.js"), 1);
+var PT_TO_PX2 = 96 / 72;
+function faceKey(family, bold, italic) {
+  return `${family.toLowerCase()}|${bold ? "b" : ""}|${italic ? "i" : ""}`;
+}
+var FontRegistry = class {
+  faces = /* @__PURE__ */ new Map();
+  /** Per-face memo: code point → the file that serves it (or its .notdef fallback). */
+  glyphMemo = /* @__PURE__ */ new Map();
+  /** Register a parsed opentype font for a family + variant (appends to the
+   *  face's file list; register subset files in coverage-priority order). */
+  register(family, variant, font) {
+    const key = faceKey(family, !!variant.bold, !!variant.italic);
+    const list = this.faces.get(key);
+    if (list) list.push(font);
+    else this.faces.set(key, [font]);
+    this.glyphMemo.clear();
+  }
+  /** Parse font-file bytes (TTF/OTF/WOFF) and register the resulting face. */
+  registerBytes(family, variant, bytes) {
+    this.register(family, variant, opentype.parse(bytes));
+  }
+  /** The files backing a spec: the exact family+bold+italic face, else the
+   *  family's regular face, else empty. */
+  files(spec) {
+    return this.faces.get(faceKey(spec.family, spec.bold, spec.italic)) ?? this.faces.get(faceKey(spec.family, false, false)) ?? [];
+  }
+  /** Whether any registered file can serve this spec. */
+  has(spec) {
+    return this.files(spec).length > 0;
+  }
+  /** The face's first file, for shared vertical metrics (all subset files of one
+   *  face carry the same hhea/head metrics), or null. */
+  primary(spec) {
+    return this.files(spec)[0] ?? null;
+  }
+  /** The file in the face that has a glyph for `codePoint`, else the first file
+   *  (whose .notdef advance is used), else null. Memoised per face. */
+  fileForCodePoint(spec, codePoint) {
+    const list = this.files(spec);
+    if (list.length === 0) return null;
+    if (list.length === 1) return list[0];
+    const key = faceKey(spec.family, spec.bold, spec.italic);
+    let memo = this.glyphMemo.get(key);
+    if (!memo) {
+      memo = /* @__PURE__ */ new Map();
+      this.glyphMemo.set(key, memo);
+    }
+    const cached = memo.get(codePoint);
+    if (cached) return cached;
+    const ch = String.fromCodePoint(codePoint);
+    const found = list.find((f) => f.charToGlyph(ch).index !== 0) ?? list[0];
+    memo.set(codePoint, found);
+    return found;
+  }
+};
+function createFontRegistryMeasurer(registry, fallback) {
+  return (text, font) => {
+    if (!registry.has(font)) return fallback(text, font);
+    const px = font.sizePt * PT_TO_PX2;
+    let total = 0;
+    for (const ch of text) {
+      const file = registry.fileForCodePoint(font, ch.codePointAt(0) ?? 0);
+      if (!file) continue;
+      total += (file.charToGlyph(ch).advanceWidth ?? 0) / file.unitsPerEm * px;
+    }
+    return total;
+  };
+}
+function createFontRegistryMetrics(registry, fallback) {
+  return (font) => {
+    const face = registry.primary(font);
+    if (!face) return fallback(font);
+    const scale = font.sizePt * PT_TO_PX2 / face.unitsPerEm;
+    return { ascent: face.ascender * scale, descent: Math.abs(face.descender) * scale };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FontRegistry,
+  createApproxMeasurer,
+  createApproxMetrics,
+  createCanvasMeasurer,
+  createCanvasMetrics,
+  createFontRegistryMeasurer,
+  createFontRegistryMetrics,
+  ensureFontsLoaded,
+  fontToCss
+});

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/measuring.js';
+export * from './lib/font-registry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC"}

package/dist/index.js

@@ -0,0 +1,139 @@
+// packages/measuring/src/lib/measuring.ts
+var PT_TO_PX = 96 / 72;
+function fontToCss(font) {
+  const style = font.italic ? "italic " : "";
+  const weight = font.bold ? "700 " : "400 ";
+  return `${style}${weight}${font.sizePt}pt ${font.family}`;
+}
+function createCanvasMeasurer() {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("bapbong-measuring: 2D canvas context unavailable");
+  return (text, font) => {
+    ctx.font = fontToCss(font);
+    return ctx.measureText(text).width;
+  };
+}
+function createApproxMeasurer(factor = 0.5) {
+  return (text, font) => text.length * font.sizePt * factor;
+}
+function createCanvasMetrics() {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("bapbong-measuring: 2D canvas context unavailable");
+  return (font) => {
+    ctx.font = fontToCss(font);
+    const m = ctx.measureText("Mg");
+    const ascent = m.fontBoundingBoxAscent ?? m.actualBoundingBoxAscent;
+    const descent = m.fontBoundingBoxDescent ?? m.actualBoundingBoxDescent;
+    return { ascent, descent };
+  };
+}
+function createApproxMetrics() {
+  return (font) => {
+    const em = font.sizePt * PT_TO_PX;
+    return { ascent: em * 0.8, descent: em * 0.2 };
+  };
+}
+async function ensureFontsLoaded(families, sizePt = 12) {
+  const fonts = globalThis.document?.fonts;
+  if (!fonts?.load) return;
+  const variants = ["", "italic ", "700 ", "italic 700 "];
+  const loads = [];
+  for (const family of new Set(families)) {
+    for (const variant of variants) {
+      loads.push(fonts.load(`${variant}${sizePt}pt "${family}"`).catch(() => []));
+    }
+  }
+  await Promise.all(loads);
+}
+
+// packages/measuring/src/lib/font-registry.ts
+import * as opentype from "opentype.js";
+var PT_TO_PX2 = 96 / 72;
+function faceKey(family, bold, italic) {
+  return `${family.toLowerCase()}|${bold ? "b" : ""}|${italic ? "i" : ""}`;
+}
+var FontRegistry = class {
+  faces = /* @__PURE__ */ new Map();
+  /** Per-face memo: code point → the file that serves it (or its .notdef fallback). */
+  glyphMemo = /* @__PURE__ */ new Map();
+  /** Register a parsed opentype font for a family + variant (appends to the
+   *  face's file list; register subset files in coverage-priority order). */
+  register(family, variant, font) {
+    const key = faceKey(family, !!variant.bold, !!variant.italic);
+    const list = this.faces.get(key);
+    if (list) list.push(font);
+    else this.faces.set(key, [font]);
+    this.glyphMemo.clear();
+  }
+  /** Parse font-file bytes (TTF/OTF/WOFF) and register the resulting face. */
+  registerBytes(family, variant, bytes) {
+    this.register(family, variant, opentype.parse(bytes));
+  }
+  /** The files backing a spec: the exact family+bold+italic face, else the
+   *  family's regular face, else empty. */
+  files(spec) {
+    return this.faces.get(faceKey(spec.family, spec.bold, spec.italic)) ?? this.faces.get(faceKey(spec.family, false, false)) ?? [];
+  }
+  /** Whether any registered file can serve this spec. */
+  has(spec) {
+    return this.files(spec).length > 0;
+  }
+  /** The face's first file, for shared vertical metrics (all subset files of one
+   *  face carry the same hhea/head metrics), or null. */
+  primary(spec) {
+    return this.files(spec)[0] ?? null;
+  }
+  /** The file in the face that has a glyph for `codePoint`, else the first file
+   *  (whose .notdef advance is used), else null. Memoised per face. */
+  fileForCodePoint(spec, codePoint) {
+    const list = this.files(spec);
+    if (list.length === 0) return null;
+    if (list.length === 1) return list[0];
+    const key = faceKey(spec.family, spec.bold, spec.italic);
+    let memo = this.glyphMemo.get(key);
+    if (!memo) {
+      memo = /* @__PURE__ */ new Map();
+      this.glyphMemo.set(key, memo);
+    }
+    const cached = memo.get(codePoint);
+    if (cached) return cached;
+    const ch = String.fromCodePoint(codePoint);
+    const found = list.find((f) => f.charToGlyph(ch).index !== 0) ?? list[0];
+    memo.set(codePoint, found);
+    return found;
+  }
+};
+function createFontRegistryMeasurer(registry, fallback) {
+  return (text, font) => {
+    if (!registry.has(font)) return fallback(text, font);
+    const px = font.sizePt * PT_TO_PX2;
+    let total = 0;
+    for (const ch of text) {
+      const file = registry.fileForCodePoint(font, ch.codePointAt(0) ?? 0);
+      if (!file) continue;
+      total += (file.charToGlyph(ch).advanceWidth ?? 0) / file.unitsPerEm * px;
+    }
+    return total;
+  };
+}
+function createFontRegistryMetrics(registry, fallback) {
+  return (font) => {
+    const face = registry.primary(font);
+    if (!face) return fallback(font);
+    const scale = font.sizePt * PT_TO_PX2 / face.unitsPerEm;
+    return { ascent: face.ascender * scale, descent: Math.abs(face.descender) * scale };
+  };
+}
+export {
+  FontRegistry,
+  createApproxMeasurer,
+  createApproxMetrics,
+  createCanvasMeasurer,
+  createCanvasMetrics,
+  createFontRegistryMeasurer,
+  createFontRegistryMetrics,
+  ensureFontsLoaded,
+  fontToCss
+};

package/dist/lib/font-registry.d.ts

@@ -0,0 +1,54 @@
+import * as opentype from 'opentype.js';
+import type { FontSpec, MeasureMetrics, MeasureText } from '@shadow-garden/bapbong-contracts';
+/** One requestable font variant. Missing flags default to the regular face. */
+export interface FontVariant {
+    bold?: boolean;
+    italic?: boolean;
+}
+/**
+ * Holds parsed font faces keyed by family + bold/italic and resolves per-glyph
+ * advance widths + vertical metrics from the font files. Widths derived here are
+ * byte-for-byte identical on every platform and WebView engine — that
+ * determinism is the whole reason layout is measured from fonts rather than the
+ * browser's `measureText`.
+ *
+ * A single face may be backed by **several files** because webfonts are commonly
+ * shipped subsetted by `unicode-range` (e.g. `@fontsource` splits latin /
+ * latin-ext / vietnamese). Each requested character is routed to the first file
+ * in the face that actually contains its glyph.
+ */
+export declare class FontRegistry {
+    private readonly faces;
+    /** Per-face memo: code point → the file that serves it (or its .notdef fallback). */
+    private readonly glyphMemo;
+    /** Register a parsed opentype font for a family + variant (appends to the
+     *  face's file list; register subset files in coverage-priority order). */
+    register(family: string, variant: FontVariant, font: opentype.Font): void;
+    /** Parse font-file bytes (TTF/OTF/WOFF) and register the resulting face. */
+    registerBytes(family: string, variant: FontVariant, bytes: ArrayBuffer): void;
+    /** The files backing a spec: the exact family+bold+italic face, else the
+     *  family's regular face, else empty. */
+    private files;
+    /** Whether any registered file can serve this spec. */
+    has(spec: FontSpec): boolean;
+    /** The face's first file, for shared vertical metrics (all subset files of one
+     *  face carry the same hhea/head metrics), or null. */
+    primary(spec: FontSpec): opentype.Font | null;
+    /** The file in the face that has a glyph for `codePoint`, else the first file
+     *  (whose .notdef advance is used), else null. Memoised per face. */
+    fileForCodePoint(spec: FontSpec, codePoint: number): opentype.Font | null;
+}
+/**
+ * A {@link MeasureText} that sums glyph advance widths from a registered face —
+ * engine-independent, unlike canvas `measureText`. Each character is routed to
+ * the subset file that contains its glyph. Families absent from the registry
+ * defer to `fallback` (e.g. a canvas measurer). Kerning is not applied, matching
+ * Word's default line-breaking (kerning-for-fonts is off by default).
+ */
+export declare function createFontRegistryMeasurer(registry: FontRegistry, fallback: MeasureText): MeasureText;
+/**
+ * A {@link MeasureMetrics} reading a registered face's hhea ascent/descent
+ * (scaled to px), deferring to `fallback` for unknown families.
+ */
+export declare function createFontRegistryMetrics(registry: FontRegistry, fallback: MeasureMetrics): MeasureMetrics;
+//# sourceMappingURL=font-registry.d.ts.map

package/dist/lib/font-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-registry.d.ts","sourceRoot":"","sources":["../../src/lib/font-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAI9F,+EAA+E;AAC/E,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAOD;;;;;;;;;;;GAWG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsC;IAC5D,qFAAqF;IACrF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiD;IAE3E;+EAC2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,IAAI;IAQzE,4EAA4E;IAC5E,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI;IAI7E;6CACyC;IACzC,OAAO,CAAC,KAAK;IAQb,uDAAuD;IACvD,GAAG,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO;IAI5B;2DACuD;IACvD,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC,IAAI,GAAG,IAAI;IAI7C;yEACqE;IACrE,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAC,IAAI,GAAG,IAAI;CAiB1E;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,WAAW,GAAG,WAAW,CAYrG;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,cAAc,GAAG,cAAc,CAO1G"}

package/dist/lib/measuring.d.ts

@@ -0,0 +1,32 @@
+import type { FontSpec, MeasureMetrics, MeasureText } from '@shadow-garden/bapbong-contracts';
+/** CSS font shorthand for a FontSpec, e.g. "italic 700 11pt Arial". */
+export declare function fontToCss(font: FontSpec): string;
+/**
+ * Canvas-backed text measurer (browser). Reuses a single offscreen 2D context,
+ * which is the accurate way to size text before painting it on canvas.
+ */
+export declare function createCanvasMeasurer(): MeasureText;
+/**
+ * Headless approximate measurer (no DOM): width ≈ chars × sizePt × factor.
+ * For SSR/tests, or as a first-paint estimate before fonts load.
+ */
+export declare function createApproxMeasurer(factor?: number): MeasureText;
+/**
+ * Canvas-backed vertical metrics (browser). Reads the font bounding box so the
+ * layout engine can build baseline-accurate line boxes.
+ */
+export declare function createCanvasMetrics(): MeasureMetrics;
+/**
+ * Headless approximate metrics (no DOM): ascent ≈ 0.8·em, descent ≈ 0.2·em.
+ * For SSR/tests, or before web fonts load.
+ */
+export declare function createApproxMetrics(): MeasureMetrics;
+/**
+ * Wait for the given font families to be usable before measuring — otherwise
+ * `measureText` runs against fallback fonts and every wrap/pagination
+ * coordinate is wrong once the real font arrives. Loads the four common
+ * variants per family. Resolves immediately where the CSS Font Loading API is
+ * unavailable (headless/tests) or for fonts the browser can't load.
+ */
+export declare function ensureFontsLoaded(families: string[], sizePt?: number): Promise<void>;
+//# sourceMappingURL=measuring.d.ts.map

package/dist/lib/measuring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measuring.d.ts","sourceRoot":"","sources":["../../src/lib/measuring.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAI9F,uEAAuE;AACvE,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAIhD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,WAAW,CAQlD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,SAAM,GAAG,WAAW,CAE9D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,cAAc,CAWpD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,cAAc,CAKpD;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,MAAM,SAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAYtF"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@shadow-garden/bapbong-measuring",
+  "version": "0.1.0",
+  "description": "bapbong — text measurement (canvas) + font helpers",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shadowgarden-app/bapbong.git",
+    "directory": "packages/measuring"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@shadow-garden/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "nx": {
+    "tags": [
+      "scope:measuring"
+    ],
+    "targets": {
+      "build": {
+        "executor": "@nx/esbuild:esbuild",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "packages/measuring/dist",
+          "main": "packages/measuring/src/index.ts",
+          "tsConfig": "packages/measuring/tsconfig.lib.json",
+          "format": [
+            "esm",
+            "cjs"
+          ],
+          "declarationRootDir": "packages/measuring/src",
+          "external": [
+            "@shadow-garden/bapbong-contracts"
+          ]
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "opentype.js": "^2.0.0",
+    "@shadow-garden/bapbong-contracts": "^0.1.0"
+  }
+}