@hankchen/canvas-image-renderer 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,835 @@
+// src/backend.ts
+import { createCanvas as createCanvas3 } from "@napi-rs/canvas";
+
+// src/color.ts
+function parseColor(s) {
+  const h = s.startsWith("#") ? s.slice(1) : s;
+  let hex;
+  switch (h.length) {
+    case 3:
+    case 4: {
+      hex = Array.from(h, (ch) => ch + ch).join("");
+      break;
+    }
+    case 6:
+    case 8:
+      hex = h;
+      break;
+    default:
+      throw new Error(`\u65E0\u6CD5\u89E3\u6790\u989C\u8272 ${JSON.stringify(s)}: \u652F\u6301 #rgb/#rgba/#rrggbb/#rrggbbaa`);
+  }
+  const c = [0, 0, 0, 0];
+  for (let i = 0; i < hex.length; i += 1) {
+    c[i / 2 | 0] = c[i / 2 | 0] * 16 + hexDigit(hex[i], s);
+  }
+  if (hex.length === 6) {
+    c[3] = 255;
+  }
+  return { r: c[0], g: c[1], b: c[2], a: c[3] };
+}
+function hexDigit(ch, source) {
+  const code = ch.charCodeAt(0);
+  if (code >= 48 && code <= 57) return code - 48;
+  if (code >= 97 && code <= 102) return code - 97 + 10;
+  if (code >= 65 && code <= 70) return code - 65 + 10;
+  throw new Error(`\u65E0\u6CD5\u89E3\u6790\u989C\u8272 ${JSON.stringify(source)}: \u975E\u6CD5\u5341\u516D\u8FDB\u5236\u4F4D ${JSON.stringify(ch)}`);
+}
+function cssColor(c) {
+  return `rgba(${c.r},${c.g},${c.b},${c.a / 255})`;
+}
+
+// src/decode.ts
+import { Image, loadImage } from "@napi-rs/canvas";
+import { readFileSync } from "fs";
+function loadSourceBytes(src, registry) {
+  const hit = registry?.get(src);
+  if (hit) {
+    return hit;
+  }
+  if (src.startsWith("data:")) {
+    const comma = src.indexOf(",");
+    if (comma < 0 || !src.slice(0, comma).endsWith(";base64")) {
+      return null;
+    }
+    return new Uint8Array(Buffer.from(src.slice(comma + 1), "base64"));
+  }
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(src)) {
+    return null;
+  }
+  try {
+    return new Uint8Array(readFileSync(src));
+  } catch {
+    return null;
+  }
+}
+function decodeHeaderSize(bytes) {
+  const img = new Image();
+  img.src = Buffer.from(bytes);
+  if (img.width <= 0 || img.height <= 0) {
+    return null;
+  }
+  return { width: img.width, height: img.height };
+}
+async function decodeDrawableImage(bytes) {
+  try {
+    return await loadImage(Buffer.from(bytes));
+  } catch {
+    return null;
+  }
+}
+
+// src/exif.ts
+function exifOrientation(data) {
+  if (data.length < 4 || data[0] !== 255 || data[1] !== 216) {
+    return 1;
+  }
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let pos = 2;
+  while (pos + 4 <= data.length && data[pos] === 255) {
+    const marker = data[pos + 1];
+    if (marker === 255) {
+      pos += 1;
+      continue;
+    }
+    if (marker === 216 || marker === 1 || marker === 217) {
+      pos += 2;
+      continue;
+    }
+    const segLen = view.getUint16(pos + 2);
+    if (segLen < 2 || pos + 2 + segLen > data.length) {
+      return 1;
+    }
+    if (marker === 218) {
+      return 1;
+    }
+    if (marker === 225 && segLen >= 8 && isExifHeader(data, pos + 4)) {
+      return parseTIFFOrientation(data.subarray(pos + 10, pos + 2 + segLen));
+    }
+    pos += 2 + segLen;
+  }
+  return 1;
+}
+function isExifHeader(data, offset) {
+  return data[offset] === 69 && data[offset + 1] === 120 && data[offset + 2] === 105 && data[offset + 3] === 102 && data[offset + 4] === 0 && data[offset + 5] === 0;
+}
+function parseTIFFOrientation(tiff) {
+  if (tiff.length < 8) {
+    return 1;
+  }
+  const le = tiff[0] === 73 && tiff[1] === 73;
+  const be = tiff[0] === 77 && tiff[1] === 77;
+  if (!le && !be) {
+    return 1;
+  }
+  const view = new DataView(tiff.buffer, tiff.byteOffset, tiff.byteLength);
+  const u16 = (o) => view.getUint16(o, le);
+  const u32 = (o) => view.getUint32(o, le);
+  if (u16(2) !== 42) {
+    return 1;
+  }
+  const ifd0 = u32(4);
+  if (ifd0 < 8 || ifd0 + 2 > tiff.length) {
+    return 1;
+  }
+  const entries = u16(ifd0);
+  for (let i = 0; i < entries; i += 1) {
+    const e = ifd0 + 2 + i * 12;
+    if (e + 12 > tiff.length) {
+      return 1;
+    }
+    if (u16(e) !== 274) {
+      continue;
+    }
+    let v;
+    switch (u16(e + 2)) {
+      // 字段类型：3 SHORT / 4 LONG，值内联于条目
+      case 3:
+        v = u16(e + 8);
+        break;
+      case 4:
+        v = u32(e + 8);
+        break;
+      default:
+        return 1;
+    }
+    return v >= 1 && v <= 8 ? v : 1;
+  }
+  return 1;
+}
+function canonicalSourceRect(raw, orientation, sw, sh) {
+  const { x, y, width, height } = raw;
+  switch (orientation) {
+    case 2:
+      return { x: sw - x - width, y, width, height };
+    case 3:
+      return { x: sw - x - width, y: sh - y - height, width, height };
+    case 4:
+      return { x, y: sh - y - height, width, height };
+    case 5:
+      return { x: y, y: x, width: height, height: width };
+    case 6:
+      return { x: sh - y - height, y: x, width: height, height: width };
+    case 7:
+      return { x: sh - y - height, y: sw - x - width, width: height, height: width };
+    case 8:
+      return { x: y, y: sw - x - width, width: height, height: width };
+    default:
+      return { x, y, width, height };
+  }
+}
+function rawDimensions(canonicalWidth, canonicalHeight, orientation) {
+  return orientation >= 5 ? { width: canonicalHeight, height: canonicalWidth } : { width: canonicalWidth, height: canonicalHeight };
+}
+
+// src/typography.ts
+import { createCanvas, GlobalFonts } from "@napi-rs/canvas";
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { createHeuristicMeasurer } from "@hankchen/canvas";
+
+// src/url.ts
+function isRemoteURL(s) {
+  try {
+    const url = new URL(s);
+    return url.protocol !== "" && url.host !== "";
+  } catch {
+    return false;
+  }
+}
+function isNumeric(s) {
+  if (s === "") return false;
+  return Number.isFinite(Number(s));
+}
+
+// src/typography.ts
+function isBuiltinFont(font) {
+  return font === "" || isNumeric(font);
+}
+function assertNotTtc(data, ref) {
+  if (data.length >= 4 && data[0] === 116 && data[1] === 116 && data[2] === 99 && data[3] === 102) {
+    throw new Error(`\u5B57\u4F53 ${ref} \u4E3A TTC/OTC \u96C6\u5408: \u672C\u6E32\u67D3\u7AEF fail-fast \u62D2\u6536\uFF08\u9B54\u6570 ttcf\uFF1B\u591A\u9762 CJK \u96C6\u5408\u9759\u9ED8\u53D6\u9ED8\u8BA4\u9762\u662F\u6700\u5371\u9669\u7684\u9759\u9ED8\u9519\u8BEF\uFF09`);
+  }
+}
+function fontAlias(data) {
+  return `ncv-${createHash("sha256").update(data).digest("hex").slice(0, 24)}`;
+}
+var registeredFonts = /* @__PURE__ */ new Map();
+function fontCacheDir() {
+  const dir = join(tmpdir(), "js-canvas-image-renderer-fonts");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function loadFontFamilyByPath(path, ref) {
+  const cached = registeredFonts.get(ref);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let data;
+  try {
+    data = new Uint8Array(readFileSync2(path));
+  } catch (error) {
+    throw new Error(`\u8BFB\u53D6\u5B57\u4F53 ${ref}: ${error.message}`);
+  }
+  return registerFontBytes(data, ref);
+}
+function registerFontBytes(data, ref) {
+  assertNotTtc(data, ref);
+  const alias = fontAlias(data);
+  if (GlobalFonts.has(alias)) {
+    registeredFonts.set(ref, alias);
+    return alias;
+  }
+  const file = join(fontCacheDir(), `${alias}.font`);
+  if (!existsSync(file)) {
+    writeFileSync(file, data);
+  }
+  try {
+    GlobalFonts.registerFromPath(file, alias);
+  } catch (error) {
+    throw new Error(`\u89E3\u6790\u5B57\u4F53 ${ref}: ${error.message}`);
+  }
+  if (!GlobalFonts.has(alias)) {
+    throw new Error(`\u89E3\u6790\u5B57\u4F53 ${ref}: \u6CE8\u518C\u540E\u672A\u547D\u4E2D\u522B\u540D\uFF08\u975E sfnt \u5B57\u4F53\u6587\u4EF6?\uFF09`);
+  }
+  registeredFonts.set(ref, alias);
+  return alias;
+}
+function registerFontData(ref, data) {
+  registerFontBytes(data, ref);
+}
+function loadFontFamily(font) {
+  if (isBuiltinFont(font)) {
+    return "sans-serif";
+  }
+  return loadFontFamilyByPath(font, font);
+}
+var measuringCtx = null;
+function ensureMeasuringCtx() {
+  if (measuringCtx === null) {
+    measuringCtx = createCanvas(16, 16).getContext("2d");
+  }
+  return measuringCtx;
+}
+var createNapiMeasurerFactory = (font, fontSize) => {
+  let family;
+  try {
+    if (!Number.isFinite(fontSize) || fontSize <= 0) {
+      return createHeuristicMeasurer(fontSize);
+    }
+    family = loadFontFamily(font);
+  } catch {
+    return createHeuristicMeasurer(fontSize);
+  }
+  const ctx = ensureMeasuringCtx();
+  const shorthand = `${fontSize}px ${family}`;
+  return {
+    measure(text) {
+      ctx.font = shorthand;
+      return ctx.measureText(text).width;
+    }
+  };
+};
+
+// src/text.ts
+import { createCanvas as createCanvas2 } from "@napi-rs/canvas";
+function baselineOffset(metrics, verticalAlign) {
+  const ascent = metrics.fontBoundingBoxAscent ?? metrics.actualBoundingBoxAscent;
+  const descent = metrics.fontBoundingBoxDescent ?? metrics.actualBoundingBoxDescent;
+  switch (verticalAlign) {
+    case "center":
+      return (ascent - descent) / 2;
+    case "bottom":
+      return -descent;
+    default:
+      return ascent;
+  }
+}
+function penOffset(width, horizontalAlign) {
+  switch (horizontalAlign) {
+    case "center":
+      return -width / 2;
+    case "right":
+      return -width;
+    default:
+      return 0;
+  }
+}
+function drawTextLine(ctx, line, x, y, options) {
+  if (line === "") {
+    return;
+  }
+  let fill;
+  try {
+    fill = cssColor(parseColor(options.fontColor));
+  } catch (error) {
+    throw new Error(`\u89E3\u6790\u5B57\u8272: ${error.message}`);
+  }
+  const family = loadFontFamily(options.font);
+  const shorthand = `${options.fontSize}px ${family}`;
+  ctx.font = shorthand;
+  ctx.textAlign = "left";
+  ctx.textBaseline = "alphabetic";
+  const metrics = ctx.measureText(line);
+  const width = metrics.width;
+  const penX = penOffset(width, options.horizontalAlign);
+  const baselineY = baselineOffset(metrics, options.verticalAlign);
+  if (options.angle === 0) {
+    ctx.fillStyle = fill;
+    ctx.fillText(line, x + penX, y + baselineY);
+    return;
+  }
+  drawRotatedText(ctx, line, fill, shorthand, metrics, x, y, options.angle, penX, baselineY);
+}
+function drawRotatedText(ctx, line, fill, shorthand, metrics, x, y, angle, penX, baselineY) {
+  const ascent = metrics.fontBoundingBoxAscent ?? metrics.actualBoundingBoxAscent;
+  const descent = metrics.fontBoundingBoxDescent ?? metrics.actualBoundingBoxDescent;
+  const boxHeight = ascent + descent;
+  const margin = 2 + Math.ceil(boxHeight / 16);
+  const offscreen = createCanvas2(Math.ceil(metrics.width) + 2 * margin, Math.ceil(boxHeight) + 2 * margin);
+  const offCtx = offscreen.getContext("2d");
+  offCtx.font = shorthand;
+  offCtx.fillStyle = fill;
+  offCtx.textAlign = "left";
+  offCtx.textBaseline = "alphabetic";
+  offCtx.fillText(line, margin, margin + ascent);
+  const ax = margin - penX;
+  const ay = margin + ascent - baselineY;
+  const rad = angle * Math.PI / 180;
+  const cos = Math.cos(rad);
+  const sin = Math.sin(rad);
+  ctx.save();
+  ctx.translate(x, y);
+  ctx.transform(cos, -sin, sin, cos, -ax, -ay);
+  ctx.drawImage(offscreen, 0, 0);
+  ctx.restore();
+}
+
+// src/backend.ts
+var ImageRendererBackend = class {
+  surface = null;
+  ctx = null;
+  /** 图像登记表（核心 setImage 缝）：键 = wire src 引用（`qr:` 前缀/远程 URL/任意键） */
+  registry = /* @__PURE__ */ new Map();
+  /** 解码缓存：键 = src 引用；null = 装配失败标记（静默不画） */
+  decoded = /* @__PURE__ */ new Map();
+  /** begin 取渲染面；未建面即调用绘制原语属用法错误（模板保证先 begin） */
+  canvasCtx() {
+    if (this.ctx === null || this.surface === null) {
+      throw new Error("\u4F4D\u56FE\u6E32\u67D3\u9762\u672A\u521D\u59CB\u5316:\u5E94\u7ECF\u6E32\u67D3\u6A21\u677F Begin \u5EFA\u9762");
+    }
+    return this.ctx;
+  }
+  /**
+   * 渲染前异步预备：解析 src（登记表/data URL/本地路径）并解码出可绘制位图进
+   * 缓存。幂等；返回是否可绘制。默认 resolver 物化时逐 src 调用——手工装配
+   * 后端时须自行预热，否则 drawImage 静默不画（见文件头「结构性差异」注）
+   */
+  async preload(src) {
+    if (this.decoded.has(src)) {
+      return this.decoded.get(src) !== null;
+    }
+    const bytes = loadSourceBytes(src, this.registry);
+    if (bytes === null) {
+      this.decoded.set(src, null);
+      return false;
+    }
+    const image = await decodeDrawableImage(bytes);
+    if (image === null) {
+      this.decoded.set(src, null);
+      return false;
+    }
+    this.decoded.set(src, { image, orientation: exifOrientation(bytes) });
+    return true;
+  }
+  /** 创建渲染面（width/height ≤0 报错；全新透明画布，对位 image.NewNRGBA） */
+  begin(width, height) {
+    if (width <= 0 || height <= 0) {
+      throw new Error(`\u6E32\u67D3\u9762\u5C3A\u5BF8\u975E\u6CD5: ${width}x${height}`);
+    }
+    this.surface = createCanvas3(width, height);
+    this.ctx = this.surface.getContext("2d");
+  }
+  /** 收尾：encodeSync('png') 透明底产物；未建面返回 null（对位 go 字面 nil） */
+  end() {
+    if (this.surface === null) {
+      return null;
+    }
+    return new Uint8Array(this.surface.encodeSync("png"));
+  }
+  /**
+   * 矩形盒：背景色 + 四边边框。背景为 null 或空串跳过填充（PHP 同款守卫）；
+   * 边框 = 四边各一条线宽=边框宽的直线（非描边矩形），按盒内嵌绘制，逐边可
+   * null/零宽不计，序 top/bottom/left/right（PHP 绘制序，后画覆盖先画；
+   * canvas source-over 合成 = go draw.Over 同语义）
+   */
+  drawRect(x, y, width, height, bgColor, border) {
+    const ctx = this.canvasCtx();
+    if (bgColor !== null && bgColor !== "") {
+      ctx.fillStyle = cssColor(parseColor(bgColor));
+      ctx.fillRect(x, y, width, height);
+    }
+    const bands = [];
+    if (border.top !== null && border.top.width > 0) {
+      bands.push({ band: [x, y, width, border.top.width], color: border.top.color });
+    }
+    if (border.bottom !== null && border.bottom.width > 0) {
+      const bandY = Math.max(y, y + height - border.bottom.width);
+      bands.push({ band: [x, bandY, width, y + height - bandY], color: border.bottom.color });
+    }
+    if (border.left !== null && border.left.width > 0) {
+      bands.push({ band: [x, y, border.left.width, height], color: border.left.color });
+    }
+    if (border.right !== null && border.right.width > 0) {
+      const bandX = Math.max(x, x + width - border.right.width);
+      bands.push({ band: [bandX, y, x + width - bandX, height], color: border.right.color });
+    }
+    for (const { band, color } of bands) {
+      let fill;
+      try {
+        fill = cssColor(parseColor(color));
+      } catch (error) {
+        throw new Error(`\u89E3\u6790\u8FB9\u6846\u8272: ${error.message}`);
+      }
+      ctx.fillStyle = fill;
+      ctx.fillRect(band[0], band[1], band[2], band[3]);
+    }
+  }
+  /**
+   * 图片双矩形 blit（ADR 0024）：把 src 的 srcRect 子矩形拉伸搬运到 dstRect。
+   * srcRect 是 raw（内在坐标）空间窗口——napi 位图是 canonical（EXIF 自动转正）
+   * 空间，非整图窗口经 canonicalSourceRect 映射进 canonical（04 号决议像素面
+   * 口径的落地机制，与 go「先裁后转」逐像素等价）；整图哨兵（零宽高）直取
+   * canonical 整图（raw 全图转正 = canonical 全图，恒等免映射）。
+   * dstRect 尺寸 ≤0 防护先于读取跳过；src 未装配/装配失败/映射窗与位图不相交
+   * 一律静默不画（缺省约定，见文件头）
+   */
+  drawImage(src, srcRect, dstRect) {
+    const ctx = this.canvasCtx();
+    if (dstRect.width <= 0 || dstRect.height <= 0) {
+      return;
+    }
+    const entry = this.decoded.get(src);
+    if (entry === void 0 || entry === null) {
+      return;
+    }
+    const { image, orientation } = entry;
+    let window;
+    if (srcRect.width <= 0 || srcRect.height <= 0) {
+      window = { x: 0, y: 0, width: image.width, height: image.height };
+    } else {
+      const raw = rawDimensions(image.width, image.height, orientation);
+      window = canonicalSourceRect(srcRect, orientation, raw.width, raw.height);
+    }
+    const x0 = Math.max(0, Math.ceil(window.x));
+    const y0 = Math.max(0, Math.ceil(window.y));
+    const x1 = Math.min(image.width, window.x + window.width);
+    const y1 = Math.min(image.height, window.y + window.height);
+    if (x1 <= x0 || y1 <= y0) {
+      return;
+    }
+    ctx.drawImage(image, x0, y0, x1 - x0, y1 - y0, dstRect.x, dstRect.y, dstRect.width, dstRect.height);
+  }
+  /**
+   * 单行文本（对位 go text.go DrawText）：原语层永远真实字体绘制——字体装配/
+   * TTC 拒收/内置默认字体判定/对齐锚点与基线差/角度旋转见 text.ts
+   * （drawTextLine）。空行零副作用；字色解析失败中止
+   */
+  drawText(line, x, y, options) {
+    const ctx = this.canvasCtx();
+    drawTextLine(ctx, line, x, y, options);
+  }
+  /**
+   * 源图内在尺寸度量（ADR 0023/0024 查询口）：返 raw（未转正）尺寸——对位
+   * go image.DecodeConfig / PHP getimagesize 的内在坐标系。查不到/解码失败返
+   * null → 核心统一退化 fill 形态。
+   * 两路在「raw 出参」契约上收敛（napi 同步/异步口径差异的实测收敛，见
+   * decode.ts decodeHeaderSize docblock）：
+   * - preload 缓存命中：位图是 canonical（异步解码已转正），按 DecodedEntry
+   *   已存的 orientation ≥5 互换换回 raw（评审 P0-3：缓存臂不重读磁盘重算
+   *   orientation——字节不可得时兜底 1 会产出 canonical 错误空间尺寸；不产出
+   *   空间错误的尺寸，弃用既有已存数据更是错上加错）；
+   * - 未装配 src：同步头部探测直出 raw 头尺寸（同步口不施加转正），原样返回
+   */
+  imageIntrinsicSize(src) {
+    const cached = this.decoded.get(src);
+    if (cached !== void 0 && cached !== null) {
+      return rawDimensions(cached.image.width, cached.image.height, cached.orientation);
+    }
+    const bytes = loadSourceBytes(src, this.registry);
+    if (bytes === null) {
+      return null;
+    }
+    return decodeHeaderSize(bytes);
+  }
+  /**
+   * 图像登记缝（核心 setImage 契约）：物化器按键登记资源字节，键即 drawImage
+   * 收到的 src 引用。字节拷贝入表（所有权归登记表，防外部原地改写）；同键重
+   * 登记使解码缓存失效（下次 preload 重装配）
+   */
+  setImage(key, data) {
+    this.registry.set(key, new Uint8Array(data));
+    this.decoded.delete(key);
+  }
+  /**
+   * 字体物化缝（resolver 的远程字体下载字节按键登记；核心 ResourceResolver
+   * 契约「注册缝归后端包契约」的本包落点）：TTC 拒收与 GlobalFonts 注册在
+   * 此处完成（物化阶段 fail-fast，渲染不带病启动），drawText 以 wire font
+   * 引用（URL 原文）直取。幂等（同字节同别名）
+   */
+  registerFont(ref, data) {
+    registerFontData(ref, data);
+  }
+};
+
+// src/resolver.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import {
+  qrImageSrc,
+  ResourceMaterializeError as ResourceMaterializeError2,
+  layerWidth
+} from "@hankchen/canvas";
+
+// src/qr.ts
+import QRCode from "qrcode";
+import { Buffer as Buffer2 } from "buffer";
+import { ResourceMaterializeError } from "@hankchen/canvas";
+var QrCodeMaterializer = class {
+  async materialize(text, width) {
+    const size = Math.max(width, 1);
+    const segment = segmentFor(text, pickEncMode(text));
+    try {
+      const code = QRCode.create([segment], { errorCorrectionLevel: "H" });
+      const blockWidth = Math.min(Math.max(Math.trunc(size / code.modules.size), 1), 255);
+      const png = await QRCode.toBuffer([segment], {
+        errorCorrectionLevel: "H",
+        margin: 0,
+        scale: blockWidth,
+        color: { dark: "#000000ff", light: "#ffffffff" }
+      });
+      return new Uint8Array(png);
+    } catch (error) {
+      throw new ResourceMaterializeError("qr_generate_failed", `\u4E8C\u7EF4\u7801\u751F\u6210\u5931\u8D25(${text}): ${error.message}`);
+    }
+  }
+};
+function pickEncMode(text) {
+  if (text === "") {
+    return "byte";
+  }
+  if (isAllDigits(text)) {
+    return "numeric";
+  }
+  if (isAllAlphaNum(text)) {
+    return "alphanumeric";
+  }
+  return "byte";
+}
+function segmentFor(text, mode) {
+  switch (mode) {
+    case "numeric":
+      return { data: text, mode: "numeric" };
+    case "alphanumeric":
+      return { data: text, mode: "alphanumeric" };
+    default:
+      return { data: Buffer2.from(text, "utf8"), mode: "byte" };
+  }
+}
+function isAllDigits(text) {
+  for (const ch of text) {
+    if (ch < "0" || ch > "9") {
+      return false;
+    }
+  }
+  return true;
+}
+function isAllAlphaNum(text) {
+  for (const ch of text) {
+    if ((ch < "0" || ch > "9") && (ch < "A" || ch > "Z")) {
+      switch (ch) {
+        case " ":
+        case "$":
+        case "%":
+        case "*":
+        case "+":
+        case "-":
+        case ".":
+        case "/":
+        case ":":
+          break;
+        default:
+          return false;
+      }
+    }
+  }
+  return true;
+}
+
+// src/resolver.ts
+var SUB_IMAGES = "img_layers";
+var SUB_FONTS = "text_layers";
+var SUB_QR = "qr_layers";
+function createDefaultResolver(options = {}) {
+  const fetchLike = options.fetchLike ?? ((url) => globalThis.fetch(url));
+  const qr = options.qrMaterializer === void 0 ? new QrCodeMaterializer() : options.qrMaterializer;
+  const memory = /* @__PURE__ */ new Map();
+  const cacheRoot = options.cacheRoot;
+  async function cachedRemoteBytes(sub, rawUrl) {
+    const key = `${sub}:${cacheKey(rawUrl)}`;
+    const hit = memory.get(key);
+    if (hit !== void 0) {
+      return hit;
+    }
+    const file = cacheRoot === void 0 ? null : join2(cacheRoot, sub, cacheKey(rawUrl));
+    if (file !== null) {
+      try {
+        const bytes = new Uint8Array(readFileSync3(file));
+        memory.set(key, bytes);
+        return bytes;
+      } catch {
+      }
+    }
+    const content = await download(rawUrl, fetchLike);
+    if (file !== null) {
+      try {
+        mkdirSync2(join2(cacheRoot, sub), { recursive: true });
+        writeFileSync2(file, content);
+      } catch (error) {
+        throw new ResourceMaterializeError2(
+          "resource_save_failed",
+          `remote file(${rawUrl}) save to cache path failed: ${error.message}`
+        );
+      }
+    }
+    memory.set(key, content);
+    return content;
+  }
+  async function cachedQrBytes(text, width) {
+    const key = `qr:${qrCacheKey(text, width)}`;
+    const hit = memory.get(key);
+    if (hit !== void 0) {
+      return hit;
+    }
+    const file = cacheRoot === void 0 ? null : join2(cacheRoot, SUB_QR, qrCacheKey(text, width));
+    if (file !== null) {
+      try {
+        const bytes2 = new Uint8Array(readFileSync3(file));
+        memory.set(key, bytes2);
+        return bytes2;
+      } catch {
+      }
+    }
+    const bytes = await qr.materialize(text, width);
+    if (file !== null) {
+      try {
+        mkdirSync2(join2(cacheRoot, SUB_QR), { recursive: true });
+        writeFileSync2(file, bytes);
+      } catch (error) {
+        throw new ResourceMaterializeError2("qr_generate_failed", `qr code save to cache path failed: ${error.message}`);
+      }
+    }
+    memory.set(key, bytes);
+    return bytes;
+  }
+  async function registerImage(backend, key, bytes) {
+    if (typeof backend.setImage !== "function") {
+      throw new Error("\u8D44\u6E90\u7269\u5316\u9700\u8981\u540E\u7AEF\u5B9E\u73B0 setImage \u767B\u8BB0\u7F1D\uFF08ImageRendererBackend \u5373\u5951\u5408\uFF09");
+    }
+    backend.setImage(key, bytes);
+    await preloadQuietly(backend, key);
+  }
+  async function preloadQuietly(backend, src) {
+    if (typeof backend.preload === "function") {
+      await backend.preload(src);
+    }
+  }
+  async function resolve(canvas, backend) {
+    const materialization = backend;
+    if (canvas.background !== null && canvas.background.image !== null) {
+      const image = canvas.background.image;
+      if (isRemoteURL(image)) {
+        await registerImage(materialization, image, await cachedRemoteBytes(SUB_IMAGES, image));
+      } else {
+        await preloadQuietly(materialization, image);
+      }
+    }
+    for (const layer of canvas.layers) {
+      await resolveLayer(layer, materialization);
+    }
+  }
+  async function resolveLayer(layer, backend) {
+    switch (layer.type) {
+      case "TableLayer":
+        for (const row of layer.rows) {
+          await resolveLayer(row, backend);
+        }
+        break;
+      case "TableRowLayer":
+        for (const cell of layer.cells) {
+          await resolveLayer(cell, backend);
+        }
+        break;
+      case "TableCellLayer":
+        if (layer.content !== null) {
+          await resolveLayer(layer.content, backend);
+        }
+        break;
+      case "ImageLayer": {
+        const src = layer.src;
+        if (src === null) {
+          break;
+        }
+        if (isRemoteURL(src)) {
+          await registerImage(backend, src, await cachedRemoteBytes(SUB_IMAGES, src));
+        } else {
+          await preloadQuietly(backend, src);
+        }
+        break;
+      }
+      case "TextLayer": {
+        const font = layer.font;
+        if (font === "" || isNumeric(font) || !isRemoteURL(font)) {
+          break;
+        }
+        const bytes = await cachedRemoteBytes(SUB_FONTS, font);
+        if (typeof backend.registerFont !== "function") {
+          throw new Error("\u8FDC\u7A0B\u5B57\u4F53\u7269\u5316\u9700\u8981\u540E\u7AEF\u5B9E\u73B0 registerFont \u7F1D\uFF08ImageRendererBackend \u5373\u5951\u5408\uFF09");
+        }
+        backend.registerFont(font, bytes);
+        break;
+      }
+      case "QrCodeLayer": {
+        const value = layer.value;
+        if (value === "") {
+          break;
+        }
+        if (qr === null) {
+          throw new ResourceMaterializeError2(
+            "qr_materializer_required",
+            "\u4E8C\u7EF4\u7801\u56FE\u5C42\u7269\u5316\u9700\u8981\u6CE8\u5165 QRMaterializer\uFF08ADR-0002\uFF1A\u5B9E\u73B0\u5728\u6E32\u67D3\u540E\u7AEF\u5305\uFF09"
+          );
+        }
+        await registerImage(backend, qrImageSrc(value), await cachedQrBytes(value, layerWidth(layer)));
+        break;
+      }
+    }
+  }
+  return { resolve };
+}
+async function download(rawUrl, fetchLike) {
+  let response;
+  try {
+    response = await fetchLike(rawUrl);
+  } catch (error) {
+    throw new ResourceMaterializeError2("resource_download_failed", `could not get remote file(${rawUrl}): ${error.message}`);
+  }
+  if (!response.ok) {
+    throw new ResourceMaterializeError2("resource_download_failed", `could not get remote file(${rawUrl}): HTTP ${response.status}`);
+  }
+  const buffer = await response.arrayBuffer();
+  if (buffer.byteLength === 0) {
+    throw new ResourceMaterializeError2("resource_download_failed", `could not get remote file(${rawUrl}): \u7A7A\u54CD\u5E94\u4F53`);
+  }
+  return new Uint8Array(buffer);
+}
+function cacheKey(rawUrl) {
+  const sum = createHash2("sha256").update(rawUrl).digest("hex");
+  let ext = "";
+  try {
+    const path = new URL(rawUrl).pathname;
+    ext = path.match(/(\.[a-zA-Z0-9]+)$/)?.[1] ?? "";
+  } catch {
+  }
+  return sum + ext;
+}
+function qrCacheKey(text, width) {
+  return createHash2("sha256").update(`${text}_${width}`).digest("hex") + ".png";
+}
+
+// src/index.ts
+var PACKAGE_NAME = "@hankchen/canvas-image-renderer";
+export {
+  ImageRendererBackend,
+  PACKAGE_NAME,
+  QrCodeMaterializer,
+  canonicalSourceRect,
+  createDefaultResolver,
+  createNapiMeasurerFactory,
+  cssColor,
+  decodeDrawableImage,
+  decodeHeaderSize,
+  drawTextLine,
+  exifOrientation,
+  isBuiltinFont,
+  loadFontFamily,
+  loadSourceBytes,
+  parseColor,
+  rawDimensions,
+  registerFontData
+};
+//# sourceMappingURL=index.js.map