@grida/refig 0.0.3 → 0.0.4

package/dist/{chunk-YI7PIULZ.mjs → chunk-INJ5F2RK.mjs}

@@ -6784,6 +6784,43 @@ var b4 = function(d, b) {
 var b8 = function(d, b) {
   return b4(d, b) + b4(d, b + 4) * 4294967296;
 };
+var Inflate = /* @__PURE__ */ (function() {
+  function Inflate2(opts, cb) {
+    if (typeof opts == "function")
+      cb = opts, opts = {};
+    this.ondata = cb;
+    var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768);
+    this.s = { i: 0, b: dict ? dict.length : 0 };
+    this.o = new u8(32768);
+    this.p = new u8(0);
+    if (dict)
+      this.o.set(dict);
+  }
+  Inflate2.prototype.e = function(c) {
+    if (!this.ondata)
+      err(5);
+    if (this.d)
+      err(4);
+    if (!this.p.length)
+      this.p = c;
+    else if (c.length) {
+      var n = new u8(this.p.length + c.length);
+      n.set(this.p), n.set(c, this.p.length), this.p = n;
+    }
+  };
+  Inflate2.prototype.c = function(final) {
+    this.s.i = +(this.d = final || false);
+    var bts = this.s.b;
+    var dt = inflt(this.p, this.s, this.o);
+    this.ondata(slc(dt, bts, this.s.b), this.d);
+    this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
+    this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
+  };
+  Inflate2.prototype.push = function(chunk, final) {
+    this.e(chunk), this.c(final);
+  };
+  return Inflate2;
+})();
 function inflateSync(data, opts) {
   return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
 }
@@ -6838,6 +6875,165 @@ var z64e = function(d, b) {
     ;
   return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
 };
+var UnzipPassThrough = /* @__PURE__ */ (function() {
+  function UnzipPassThrough2() {
+  }
+  UnzipPassThrough2.prototype.push = function(data, final) {
+    this.ondata(null, data, final);
+  };
+  UnzipPassThrough2.compression = 0;
+  return UnzipPassThrough2;
+})();
+var UnzipInflate = /* @__PURE__ */ (function() {
+  function UnzipInflate2() {
+    var _this = this;
+    this.i = new Inflate(function(dat, final) {
+      _this.ondata(null, dat, final);
+    });
+  }
+  UnzipInflate2.prototype.push = function(data, final) {
+    try {
+      this.i.push(data, final);
+    } catch (e) {
+      this.ondata(e, null, final);
+    }
+  };
+  UnzipInflate2.compression = 8;
+  return UnzipInflate2;
+})();
+var Unzip = /* @__PURE__ */ (function() {
+  function Unzip2(cb) {
+    this.onfile = cb;
+    this.k = [];
+    this.o = {
+      0: UnzipPassThrough
+    };
+    this.p = et;
+  }
+  Unzip2.prototype.push = function(chunk, final) {
+    var _this = this;
+    if (!this.onfile)
+      err(5);
+    if (!this.p)
+      err(4);
+    if (this.c > 0) {
+      var len = Math.min(this.c, chunk.length);
+      var toAdd = chunk.subarray(0, len);
+      this.c -= len;
+      if (this.d)
+        this.d.push(toAdd, !this.c);
+      else
+        this.k[0].push(toAdd);
+      chunk = chunk.subarray(len);
+      if (chunk.length)
+        return this.push(chunk, final);
+    } else {
+      var f = 0, i = 0, is = void 0, buf = void 0;
+      if (!this.p.length)
+        buf = chunk;
+      else if (!chunk.length)
+        buf = this.p;
+      else {
+        buf = new u8(this.p.length + chunk.length);
+        buf.set(this.p), buf.set(chunk, this.p.length);
+      }
+      var l = buf.length, oc = this.c, add = oc && this.d;
+      var _loop_2 = function() {
+        var _a2;
+        var sig = b4(buf, i);
+        if (sig == 67324752) {
+          f = 1, is = i;
+          this_1.d = null;
+          this_1.c = 0;
+          var bf = b2(buf, i + 6), cmp_1 = b2(buf, i + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i + 26), es = b2(buf, i + 28);
+          if (l > i + 30 + fnl + es) {
+            var chks_3 = [];
+            this_1.k.unshift(chks_3);
+            f = 2;
+            var sc_1 = b4(buf, i + 18), su_1 = b4(buf, i + 22);
+            var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u);
+            if (sc_1 == 4294967295) {
+              _a2 = dd ? [-2] : z64e(buf, i), sc_1 = _a2[0], su_1 = _a2[1];
+            } else if (dd)
+              sc_1 = -1;
+            i += es;
+            this_1.c = sc_1;
+            var d_1;
+            var file_1 = {
+              name: fn_1,
+              compression: cmp_1,
+              start: function() {
+                if (!file_1.ondata)
+                  err(5);
+                if (!sc_1)
+                  file_1.ondata(null, et, true);
+                else {
+                  var ctr = _this.o[cmp_1];
+                  if (!ctr)
+                    file_1.ondata(err(14, "unknown compression type " + cmp_1, 1), null, false);
+                  d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1);
+                  d_1.ondata = function(err3, dat3, final2) {
+                    file_1.ondata(err3, dat3, final2);
+                  };
+                  for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) {
+                    var dat2 = chks_4[_i];
+                    d_1.push(dat2, false);
+                  }
+                  if (_this.k[0] == chks_3 && _this.c)
+                    _this.d = d_1;
+                  else
+                    d_1.push(et, true);
+                }
+              },
+              terminate: function() {
+                if (d_1 && d_1.terminate)
+                  d_1.terminate();
+              }
+            };
+            if (sc_1 >= 0)
+              file_1.size = sc_1, file_1.originalSize = su_1;
+            this_1.onfile(file_1);
+          }
+          return "break";
+        } else if (oc) {
+          if (sig == 134695760) {
+            is = i += 12 + (oc == -2 && 8), f = 3, this_1.c = 0;
+            return "break";
+          } else if (sig == 33639248) {
+            is = i -= 4, f = 3, this_1.c = 0;
+            return "break";
+          }
+        }
+      };
+      var this_1 = this;
+      for (; i < l - 4; ++i) {
+        var state_1 = _loop_2();
+        if (state_1 === "break")
+          break;
+      }
+      this.p = et;
+      if (oc < 0) {
+        var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 134695760 && 4)) : buf.subarray(0, i);
+        if (add)
+          add.push(dat, !!f);
+        else
+          this.k[+(f == 2)].push(dat);
+      }
+      if (f & 2)
+        return this.push(buf.subarray(i), final);
+      this.p = buf.subarray(i);
+    }
+    if (final) {
+      if (this.c)
+        err(13);
+      this.p = null;
+    }
+  };
+  Unzip2.prototype.register = function(decoder) {
+    this.o[decoder.compression] = decoder;
+  };
+  return Unzip2;
+})();
 function unzipSync(data, opts) {
   var files = {};
   var e = data.length - 22;
@@ -13285,6 +13481,93 @@ function readFigFile(data) {
   }
   return { ...parseFigData(archiveData), zip_files: zipFiles };
 }
+async function readFigFileFromStream(stream) {
+  const zipFiles = {};
+  const unzip = new Unzip((file) => {
+    const fileChunks = [];
+    file.ondata = (err3, data, final) => {
+      if (err3) throw err3;
+      if (data && data.length > 0) fileChunks.push(data);
+      if (final) {
+        const size = fileChunks.reduce((s, c) => s + c.length, 0);
+        const result = new Uint8Array(size);
+        let off = 0;
+        for (const c of fileChunks) {
+          result.set(c, off);
+          off += c.length;
+        }
+        zipFiles[file.name] = result;
+      }
+    };
+    file.start();
+  });
+  unzip.register(UnzipPassThrough);
+  unzip.register(UnzipInflate);
+  const buffer = [];
+  let haveCheckedSignature = false;
+  for await (const chunk of stream) {
+    if (haveCheckedSignature) {
+      unzip.push(chunk);
+      continue;
+    }
+    buffer.push(chunk);
+    const total = buffer.reduce((s, c) => s + c.length, 0);
+    if (total < 4) continue;
+    haveCheckedSignature = true;
+    const merged = new Uint8Array(total);
+    let off = 0;
+    for (const c of buffer) {
+      merged.set(c, off);
+      off += c.length;
+    }
+    if (!isSignature(merged, ZIP_SIGNATURE)) {
+      for await (const c of stream) buffer.push(c);
+      const fullSize = buffer.reduce((s, c) => s + c.length, 0);
+      const full = new Uint8Array(fullSize);
+      off = 0;
+      for (const c of buffer) {
+        full.set(c, off);
+        off += c.length;
+      }
+      return { ...parseFigData(full), zip_files: void 0 };
+    }
+    unzip.push(merged);
+  }
+  if (!haveCheckedSignature) {
+    if (buffer.length === 0) {
+      throw new Error("readFigFileFromStream: empty stream");
+    }
+    const total = buffer.reduce((s, c) => s + c.length, 0);
+    if (total < 4) {
+      throw new Error("readFigFileFromStream: stream too short to detect format");
+    }
+    const merged = new Uint8Array(total);
+    let off = 0;
+    for (const c of buffer) {
+      merged.set(c, off);
+      off += c.length;
+    }
+    return { ...parseFigData(merged), zip_files: void 0 };
+  }
+  unzip.push(new Uint8Array(0), true);
+  const keys = Object.keys(zipFiles);
+  const mainFile = keys.find((key) => {
+    const fileData = zipFiles[key];
+    if (!fileData || fileData.length <= 8) return false;
+    const prelude = String.fromCharCode.apply(
+      String,
+      Array.from(fileData.slice(0, 8))
+    );
+    return prelude === FIG_KIWI_PRELUDE || prelude === FIGJAM_KIWI_PRELUDE;
+  }) || keys.find((k) => k.endsWith(".fig"));
+  if (!mainFile) {
+    throw new Error(
+      `ZIP archive found but no valid Figma file inside. Files: ${keys.join(", ")}`
+    );
+  }
+  const archiveData = zipFiles[mainFile];
+  return { ...parseFigData(archiveData), zip_files: zipFiles };
+}
 function parseFigData(data) {
   const { header, files } = FigmaArchiveParser.parseArchive(data);
   const [schemaFile, dataFile, preview] = files;
@@ -14098,6 +14381,8 @@ var iofigma;
               font_size: node.style.fontSize ?? 0,
               font_family: node.style.fontFamily,
               font_weight: node.style.fontWeight ?? 400,
+              font_postscript_name: node.style.fontPostScriptName || void 0,
+              font_style_italic: node.style.italic ?? false,
               font_kerning: true
             };
           }
@@ -14568,8 +14853,19 @@ var iofigma;
           }
         };
       }
+      function findFontMetaDataEntry(fontMetaData, fontName) {
+        if (!fontMetaData?.length || !fontName) return void 0;
+        const match = fontMetaData.find(
+          (m) => m.key?.family === fontName.family && m.key?.style === fontName.style
+        ) ?? fontMetaData[0];
+        return match;
+      }
       function kiwi_text_style_trait(nc) {
         const characters = nc.textData?.characters ?? "";
+        const fontMetaData = nc.derivedTextData?.fontMetaData ?? nc.textData?.fontMetaData;
+        const fontMeta = findFontMetaDataEntry(fontMetaData, nc.fontName);
+        const fontWeight = fontMeta?.fontWeight ?? 400;
+        const italic = fontMeta?.fontStyle === "ITALIC";
         return {
           characters,
           fills: nc.fillPaints ? paints(nc.fillPaints) : [],
@@ -14578,8 +14874,9 @@ var iofigma;
           strokeAlign: nc.strokeAlign ? map.strokeAlign(nc.strokeAlign) : "INSIDE",
           style: {
             fontFamily: nc.fontName?.family ?? "Inter",
-            fontPostScriptName: nc.fontName?.postscript,
-            fontWeight: 400,
+            fontPostScriptName: nc.fontName?.postscript ? nc.fontName.postscript : void 0,
+            fontWeight,
+            italic,
             fontSize: nc.fontSize ?? 12,
             textAlignHorizontal: nc.textAlignHorizontal ?? "LEFT",
             textAlignVertical: nc.textAlignVertical ?? "TOP",
@@ -14605,7 +14902,8 @@ var iofigma;
           ...kiwi_layout_trait(nc),
           ...kiwi_geometry_trait(nc),
           ...kiwi_corner_trait(nc),
-          ...kiwi_effects_trait(nc)
+          ...kiwi_effects_trait(nc),
+          ...kiwi_has_export_settings_trait(nc)
         };
       }
       function ellipse(nc) {
@@ -14616,7 +14914,8 @@ var iofigma;
           ...kiwi_layout_trait(nc),
           ...kiwi_geometry_trait(nc),
           ...kiwi_arc_data_trait(nc),
-          ...kiwi_effects_trait(nc)
+          ...kiwi_effects_trait(nc),
+          ...kiwi_has_export_settings_trait(nc)
         };
       }
       function line(nc) {
@@ -14632,6 +14931,7 @@ var iofigma;
           strokeCap: nc.strokeCap ? map.strokeCap(nc.strokeCap) : "NONE",
           strokeJoin: nc.strokeJoin ? map.strokeJoin(nc.strokeJoin) : "MITER",
           strokeMiterAngle: nc.miterLimit,
+          ...kiwi_has_export_settings_trait(nc),
           ...kiwi_effects_trait(nc)
         };
       }
@@ -14642,7 +14942,8 @@ var iofigma;
           ...kiwi_blend_opacity_trait(nc),
           ...kiwi_layout_trait(nc),
           ...kiwi_text_style_trait(nc),
-          ...kiwi_effects_trait(nc)
+          ...kiwi_effects_trait(nc),
+          ...kiwi_has_export_settings_trait(nc)
         };
       }
       function isGroupOriginatedFrame(nc) {
@@ -14667,7 +14968,8 @@ var iofigma;
             ...kiwi_children_trait(),
             clipsContent: false,
             fills: [],
-            ...kiwi_effects_trait(nc)
+            ...kiwi_effects_trait(nc),
+            ...kiwi_has_export_settings_trait(nc)
           };
         }
         return {
@@ -14719,7 +15021,8 @@ var iofigma;
           ...kiwi_corner_trait(nc),
           ...kiwi_frame_clip_trait(nc),
           ...kiwi_children_trait(),
-          ...kiwi_effects_trait(nc)
+          ...kiwi_effects_trait(nc),
+          ...kiwi_has_export_settings_trait(nc)
         };
         const symbolOverrides = nc.symbolData?.symbolOverrides;
         if (Array.isArray(symbolOverrides) && symbolOverrides.length > 0) {
@@ -14769,7 +15072,8 @@ var iofigma;
           ...kiwi_children_trait(),
           clipsContent: false,
           fills: [],
-          ...kiwi_effects_trait(nc)
+          ...kiwi_effects_trait(nc),
+          ...kiwi_has_export_settings_trait(nc)
         };
       }
       function windingRule(kiwi3) {
@@ -14796,6 +15100,7 @@ var iofigma;
                 ...kiwi_layout_trait(nc),
                 ...kiwi_geometry_trait(nc),
                 ...kiwi_effects_trait(nc),
+                ...kiwi_has_export_settings_trait(nc),
                 cornerRadius: nc.cornerRadius ?? 0,
                 vectorNetwork
               };
@@ -14815,7 +15120,8 @@ var iofigma;
             path: "",
             windingRule: path.windingRule ? windingRule(path.windingRule) : "NONZERO"
           })),
-          ...kiwi_effects_trait(nc)
+          ...kiwi_effects_trait(nc),
+          ...kiwi_has_export_settings_trait(nc)
         };
       }
       function star(nc) {
@@ -14826,6 +15132,7 @@ var iofigma;
           ...kiwi_layout_trait(nc),
           ...kiwi_geometry_trait(nc),
           ...kiwi_effects_trait(nc),
+          ...kiwi_has_export_settings_trait(nc),
           cornerRadius: nc.cornerRadius ?? 0,
           pointCount: nc.count ?? 5,
           innerRadius: nc.starInnerScale ?? 0.5
@@ -14867,7 +15174,8 @@ var iofigma;
           booleanOperation: nc.booleanOperation ?? "UNION",
           ...kiwi_geometry_trait(nc),
           ...kiwi_children_trait(),
-          ...kiwi_effects_trait(nc)
+          ...kiwi_effects_trait(nc),
+          ...kiwi_has_export_settings_trait(nc)
         };
       }
       function regularPolygon(nc) {
@@ -14878,6 +15186,7 @@ var iofigma;
           ...kiwi_layout_trait(nc),
           ...kiwi_geometry_trait(nc),
           ...kiwi_effects_trait(nc),
+          ...kiwi_has_export_settings_trait(nc),
           cornerRadius: nc.cornerRadius ?? 0,
           pointCount: nc.count ?? 3
         };
@@ -15118,6 +15427,18 @@ var iofigma;
       };
     }
     kiwi2.parseFile = parseFile;
+    async function parseFileFromStream(stream, options = {}) {
+      const figData = await readFigFileFromStream(stream);
+      const pages = extractPages(figData, options);
+      return {
+        pages,
+        metadata: {
+          version: figData.header.version
+        },
+        zip_files: figData.zip_files
+      };
+    }
+    kiwi2.parseFileFromStream = parseFileFromStream;
     function extractImages2(zipFiles) {
       return extractImages(zipFiles);
     }
@@ -15841,27 +16162,174 @@ async function ensureFigmaDefaultFonts(canvas) {
 }
 
 // lib.ts
-var FigmaDocument = class {
+function isFigFileDocument(value) {
+  return value != null && typeof value === "object" && "pages" in value && "metadata" in value && Array.isArray(value.pages);
+}
+var _FigmaDocument = class _FigmaDocument {
   /**
-   * @param input Raw `.fig` bytes (Uint8Array) or a parsed Figma REST API
-   *              document JSON object.
+   * @param input Raw `.fig` bytes (Uint8Array), a pre-parsed FigFileDocument
+   *              (e.g. from parseFileFromStream for large files), or REST JSON.
    *
    * For file-path convenience in Node, use `FigmaDocument.fromFile()` from
    * the `@grida/refig` entrypoint.
    */
   constructor(input) {
+    /**
+     * Cache of ResolvedScene per rootNodeId. REST with images is not cached.
+     * Bounded to avoid unbounded memory growth in --export-all flows.
+     */
+    this._sceneCache = /* @__PURE__ */ new Map();
     if (input instanceof Uint8Array) {
       this.sourceType = "fig-file";
       this.payload = input;
       return;
     }
+    if (isFigFileDocument(input)) {
+      this.sourceType = "fig-file";
+      this.payload = input;
+      this._figFile = input;
+      return;
+    }
     if (!input || typeof input !== "object" || Array.isArray(input)) {
-      throw new Error("FigmaDocument: input must be a Uint8Array or object");
+      throw new Error(
+        "FigmaDocument: input must be a Uint8Array, FigFileDocument, or REST JSON object"
+      );
     }
     this.sourceType = "rest-api-json";
     this.payload = input;
   }
+  /**
+   * Resolve document to Grida IR (scene JSON + images to register).
+   * On-demand, cached when deterministic (no images for REST).
+   * Cache is bounded (LRU eviction) to avoid OOM in --export-all flows.
+   * @internal
+   */
+  _resolve(rootNodeId, images) {
+    const cacheKey = rootNodeId ?? "";
+    if (this.sourceType === "fig-file") {
+      const cached = this._sceneCacheGet(cacheKey);
+      if (cached) return cached;
+      const resolved = this._figToScene(rootNodeId);
+      this._sceneCacheSet(cacheKey, resolved);
+      return resolved;
+    }
+    if (images == null || Object.keys(images).length === 0) {
+      const cached = this._sceneCacheGet(cacheKey);
+      if (cached) return cached;
+      const resolved = this._restToScene(rootNodeId);
+      this._sceneCacheSet(cacheKey, resolved);
+      return resolved;
+    }
+    return this._restToScene(rootNodeId, images);
+  }
+  _sceneCacheGet(key) {
+    const v = this._sceneCache.get(key);
+    if (v === void 0) return void 0;
+    this._sceneCache.delete(key);
+    this._sceneCache.set(key, v);
+    return v;
+  }
+  _sceneCacheSet(key, value) {
+    if (this._sceneCache.size >= _FigmaDocument._MAX_SCENE_CACHE) {
+      const firstKey = this._sceneCache.keys().next().value;
+      if (firstKey !== void 0) this._sceneCache.delete(firstKey);
+    }
+    this._sceneCache.set(key, value);
+  }
+  /** @internal */
+  _restToScene(rootNodeId, images) {
+    const result = restJsonToSceneJson(
+      this.payload,
+      rootNodeId,
+      images
+    );
+    if (images && Object.keys(images).length > 0) {
+      const imagesToRegister = {};
+      for (const ref of result.imageRefsUsed) {
+        if (ref in images) {
+          imagesToRegister[ref] = images[ref];
+        }
+      }
+      return {
+        sceneJson: result.sceneJson,
+        images: imagesToRegister,
+        imageRefsUsed: result.imageRefsUsed
+      };
+    }
+    return {
+      sceneJson: result.sceneJson,
+      images: {},
+      imageRefsUsed: result.imageRefsUsed
+    };
+  }
+  /** @internal */
+  _figToScene(rootNodeId) {
+    if (!this._figFile) {
+      this._figFile = iofigma.kiwi.parseFile(this.payload);
+    }
+    return figFileToSceneJson(this._figFile, rootNodeId);
+  }
+  /**
+   * Returns the list of font family names used in this document.
+   *
+   * The result is family names only — no weights, PostScript names, or other metadata.
+   * That is intentional: in practice, you can load all TTF/OTF files for each family
+   * (variable or static) and pass them to the renderer; it will resolve the correct face
+   * per text style. We prioritize simple usage and accurate font selection over
+   * performance or resource-optimized patterns.
+   *
+   * When rootNodeId is omitted, traverses all pages so fonts from every page are included.
+   *
+   * @param rootNodeId — Optional. When provided, scope to that node's subtree. Omit for the full document (all pages).
+   * @returns Unique font family names (e.g. `["Inter", "Caveat", "Roboto"]`).
+   */
+  listFontFamilies(rootNodeId) {
+    if (rootNodeId != null && rootNodeId !== "") {
+      const resolved = this._resolve(rootNodeId);
+      return this._collectFontFamiliesFromSceneJson(resolved.sceneJson);
+    }
+    if (this.sourceType === "rest-api-json") {
+      return collectFontFamiliesFromRestDocument(
+        this.payload
+      );
+    }
+    if (!this._figFile) {
+      this._figFile = iofigma.kiwi.parseFile(this.payload);
+    }
+    const figFile = this._figFile;
+    const pages = figFile.pages;
+    if (!pages?.length) return [];
+    const sortedPages = [...pages].sort(
+      (a, b) => a.sortkey.localeCompare(b.sortkey)
+    );
+    const families = /* @__PURE__ */ new Set();
+    for (let i = 0; i < sortedPages.length; i++) {
+      const resolved = figFileToSceneJson(figFile, void 0, i);
+      for (const f of this._collectFontFamiliesFromSceneJson(
+        resolved.sceneJson
+      )) {
+        families.add(f);
+      }
+    }
+    return Array.from(families);
+  }
+  _collectFontFamiliesFromSceneJson(sceneJson) {
+    const parsed = JSON.parse(sceneJson);
+    const nodes = parsed?.document?.nodes;
+    if (!nodes || typeof nodes !== "object") return [];
+    const families = /* @__PURE__ */ new Set();
+    for (const node of Object.values(nodes)) {
+      const family = node.font_family;
+      if (typeof family === "string" && family) {
+        families.add(family);
+      }
+    }
+    return Array.from(families);
+  }
 };
+/** Max cached scenes; evicts LRU when exceeded. */
+_FigmaDocument._MAX_SCENE_CACHE = 64;
+var FigmaDocument = _FigmaDocument;
 function resolveMimeType(format) {
   const map = {
     png: "image/png",
@@ -15968,6 +16436,28 @@ function exportSettingToRenderOptions(node, setting) {
   }
   return { format, width: DEFAULT_EXPORT_SIZE, height: DEFAULT_EXPORT_SIZE };
 }
+function collectFontFamiliesFromRestDocument(json) {
+  const families = /* @__PURE__ */ new Set();
+  const doc = json;
+  const pages = doc?.document?.children;
+  if (!pages?.length) return [];
+  function walk(nodes) {
+    for (const node of nodes) {
+      const style = node.style;
+      const family = style?.fontFamily;
+      if (typeof family === "string" && family) {
+        families.add(family);
+      }
+      const children = node.children;
+      if (children?.length) walk(children);
+    }
+  }
+  for (const page of pages) {
+    const pageChildren = page.children;
+    if (pageChildren?.length) walk(pageChildren);
+  }
+  return Array.from(families);
+}
 function findNodeInRestDocument(json, nodeId) {
   const doc = json;
   const pages = doc?.document?.children;
@@ -16134,8 +16624,7 @@ function figFileToRestLikeDocument(figFile) {
     }
   };
 }
-function figBytesToSceneJson(figBytes, rootNodeId) {
-  const figFile = iofigma.kiwi.parseFile(figBytes);
+function figFileToSceneJson(figFile, rootNodeId, pageIndex) {
   const pages = figFile.pages;
   if (!pages || pages.length === 0) {
     throw new Error("FigmaDocument: .fig file has no pages");
@@ -16152,6 +16641,8 @@ function figBytesToSceneJson(figBytes, rootNodeId) {
       );
     }
     page = pageWithNode;
+  } else if (pageIndex != null && pageIndex >= 0 && pageIndex < sortedPages.length) {
+    page = sortedPages[pageIndex];
   } else {
     page = sortedPages[0];
   }
@@ -16201,38 +16692,26 @@ var FigmaRenderer = class {
         this._canvas
       );
     }
+    if (this.options.fonts) {
+      for (const [family, data] of Object.entries(this.options.fonts)) {
+        const entries = Array.isArray(data) ? data : [data];
+        for (const bytes of entries) {
+          this._canvas.addFont(family, bytes);
+        }
+      }
+    }
     return this._canvas;
   }
   loadScene(canvas, nodeId) {
     if (this._sceneLoaded && this._requestedNodeId === nodeId) return;
-    let sceneJson;
-    let imagesToRegister = {};
-    if (this.document.sourceType === "fig-file") {
-      const figResult = figBytesToSceneJson(
-        this.document.payload,
-        nodeId || void 0
-      );
-      sceneJson = figResult.sceneJson;
-      imagesToRegister = figResult.images;
-    } else {
-      const restResult = restJsonToSceneJson(
-        this.document.payload,
-        nodeId || void 0,
-        this.options.images
-      );
-      sceneJson = restResult.sceneJson;
-      const used = new Set(restResult.imageRefsUsed);
-      const provided = this.options.images ?? {};
-      for (const ref of used) {
-        if (ref in provided) {
-          imagesToRegister[ref] = provided[ref];
-        }
-      }
-    }
-    for (const [ref, bytes] of Object.entries(imagesToRegister)) {
+    const resolved = this.document._resolve(
+      nodeId || void 0,
+      this.options.images
+    );
+    for (const [ref, bytes] of Object.entries(resolved.images)) {
       canvas.addImageWithId(bytes, `res://images/${ref}`);
     }
-    canvas.loadScene(sceneJson);
+    canvas.loadScene(resolved.sceneJson);
     this._requestedNodeId = nodeId;
     this._sceneLoaded = true;
   }