react-native-nano-icons 0.1.2 → 0.1.3

package/lib/commonjs/cli/config.js

@@ -7,19 +7,20 @@ exports.loadNanoIconsConfig = loadNanoIconsConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 /**
- * Load .nanoicons.json from the project root.
+ * Load .nanoicons.json from the given directory.
  * Throws with a helpful message if the file is missing or malformed.
  */
-function loadNanoIconsConfig(projectRoot) {
-    const configPath = node_path_1.default.join(projectRoot, '.nanoicons.json');
+function loadNanoIconsConfig(configRoot) {
+    const configPath = node_path_1.default.join(configRoot, '.nanoicons.json');
     if (!node_fs_1.default.existsSync(configPath)) {
-        throw new Error(`[react-native-nano-icons] No .nanoicons.json found at project root (${projectRoot}).\n` +
-            `Create one with: { "iconSets": [{ "inputDir": "assets/icons", "fontFamily": "MyIcons" }] }`);
+        throw new Error(`🔬❌ [react-native-nano-icons] No .nanoicons.json found at (${configRoot}).\n` +
+            `Create one with: { "iconSets": [{ "inputDir": "assets/icons", "fontFamily": "MyIcons" }] } \n` +
+            `Or run with --path <dir> to specify a different directory.`);
     }
     const raw = node_fs_1.default.readFileSync(configPath, 'utf8');
     const config = JSON.parse(raw);
     if (!config?.iconSets?.length) {
-        throw new Error(`[react-native-nano-icons] .nanoicons.json must contain an "iconSets" array with at least one entry.`);
+        throw new Error(`🔬❌ [react-native-nano-icons] .nanoicons.json must contain an "iconSets" array with at least one entry.`);
     }
     return config;
 }

package/lib/commonjs/scripts/cli.js

@@ -1,25 +1,35 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Bare React Native workflow: build icon fonts and link them into the native project.
  *
- * Run from your app root: npx react-native-nano-icons [--verbose]
+ * Run from your app root: npx react-native-nano-icons [--verbose] [--path <dir>]
  *
  * Reads .nanoicons.json (same shape as Expo plugin options) so Expo and bare apps
  * share one config format.
  *
  * Flags:
- *   --verbose   Show per-SVG processing details and pipeline timing
+ *   --verbose        Show per-SVG processing details and pipeline timing
+ *   --path <dir>     Directory containing .nanoicons.json (default: cwd)
  */
+const node_path_1 = __importDefault(require("node:path"));
 const index_js_1 = require("../cli/index.js");
 async function main() {
     const verbose = process.argv.includes('--verbose');
     const level = verbose ? 'verbose' : 'normal';
+    const pathIdx = process.argv.indexOf('--path');
+    const projectRoot = process.cwd();
+    const configRoot = pathIdx !== -1 && process.argv[pathIdx + 1]
+        ? node_path_1.default.resolve(projectRoot, process.argv[pathIdx + 1])
+        : projectRoot;
     const logger = await (0, index_js_1.createOraLogger)(level);
-    const config = (0, index_js_1.loadNanoIconsConfig)(process.cwd());
-    const built = await (0, index_js_1.buildAllFonts)(config.iconSets, process.cwd(), { logger });
-    await (0, index_js_1.linkBare)(process.cwd(), built, logger);
+    const config = (0, index_js_1.loadNanoIconsConfig)(configRoot);
+    const built = await (0, index_js_1.buildAllFonts)(config.iconSets, projectRoot, { logger });
+    await (0, index_js_1.linkBare)(projectRoot, built, logger);
 }
 main().catch((err) => {
     const message = err instanceof Error ? err.message : String(err);

package/lib/commonjs/src/core/font/compile.d.ts

@@ -1,5 +1,16 @@
-export declare function compileTtfFromGlyphSVGs(opts: {
-    glyphDir: string;
+export type FontGlyph = {
+    codepoint: number;
+    advanceWidth: number;
+    /** Path data already in font coordinates (Y-up, placement applied). */
+    d: string;
+};
+export declare function parseCompileTtfFromGlyphsError(err: unknown, codepointToIcon: Map<number, string>): void;
+/**
+ * Compile a TTF font from pre-transformed glyph data.
+ * Builds SVG font XML directly (no intermediate files), then converts via svg2ttf.
+ */
+export declare function compileTtfFromGlyphs(opts: {
+    glyphs: FontGlyph[];
     outTtfPath: string;
     fontName: string;
     upm: number;

package/lib/commonjs/src/core/font/compile.js

@@ -3,63 +3,66 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileTtfFromGlyphSVGs = compileTtfFromGlyphSVGs;
+exports.parseCompileTtfFromGlyphsError = parseCompileTtfFromGlyphsError;
+exports.compileTtfFromGlyphs = compileTtfFromGlyphs;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const node_events_1 = require("node:events");
 const metrics_js_1 = require("./metrics.js");
 const svg2ttf_1 = __importDefault(require("svg2ttf"));
-const parse_js_1 = require("../../utils/parse.js");
-async function writeGlyphStreamToFont(fontStream, svgPath, filename) {
-    const codepoint = (0, parse_js_1.parseCodepointFromFilename)(filename);
-    const name = node_path_1.default.basename(filename, '.svg');
-    return new Promise((resolve, reject) => {
-        const glyphStream = node_fs_1.default.createReadStream(svgPath);
-        glyphStream.metadata = {
-            name,
-            unicode: [String.fromCodePoint(codepoint)],
-        };
-        glyphStream.on('error', reject);
-        // Do not add fontStream.on("error", reject) here — one per glyph would exceed
-        // Node's default MaxListeners (10). Font stream errors are handled once below.
-        fontStream.write(glyphStream);
-        glyphStream.on('end', resolve);
+function escapeXml(s) {
+    return s.replace(/&/g, '&').replace(/"/g, '"');
+}
+/**
+ * Build an SVG font XML string from pre-transformed glyph data.
+ */
+function buildSvgFontXml(opts) {
+    const { fontName, glyphs, upm, ascent, descent } = opts;
+    const glyphLines = glyphs.map((g) => {
+        const hex = g.codepoint.toString(16);
+        const name = `u${hex.padStart(4, '0')}`;
+        return `<glyph glyph-name="${name}" unicode="&#x${hex};" horiz-adv-x="${g.advanceWidth}" d="${escapeXml(g.d)}"/>`;
     });
+    return `<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg">
+<defs>
+<font id="${escapeXml(fontName)}" horiz-adv-x="${upm}">
+<font-face font-family="${escapeXml(fontName)}" units-per-em="${upm}" ascent="${ascent}" descent="${-Math.abs(descent)}"/>
+<missing-glyph horiz-adv-x="0"/>
+${glyphLines.join('\n')}
+</font>
+</defs>
+</svg>`;
+}
+function parseCompileTtfFromGlyphsError(err, codepointToIcon) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const cpMatch = msg.match(/glyph\s+"u([0-9a-fA-F]+)"/);
+    if (cpMatch) {
+        const cp = parseInt(cpMatch[1], 16);
+        const iconName = codepointToIcon.get(cp);
+        const detail = iconName
+            ? `icon "${iconName}" (codepoint u${cpMatch[1]})`
+            : `codepoint u${cpMatch[1]}`;
+        throw new Error(`Font compilation failed for ${detail}: ${msg}`);
+    }
+    throw err;
 }
-async function compileTtfFromGlyphSVGs(opts) {
-    const { SVGIcons2SVGFontStream } = await import('svgicons2svgfont');
-    const { glyphDir, outTtfPath, fontName, upm, ascent, descent } = opts;
+/**
+ * Compile a TTF font from pre-transformed glyph data.
+ * Builds SVG font XML directly (no intermediate files), then converts via svg2ttf.
+ */
+async function compileTtfFromGlyphs(opts) {
+    const { glyphs, outTtfPath, fontName, upm, ascent, descent } = opts;
     const lineGap = opts.lineGap ?? 0;
-    const files = node_fs_1.default
-        .readdirSync(glyphDir)
-        .filter((f) => /^u[0-9a-fA-F]+\.svg$/.test(f))
-        .sort((a, b) => (0, parse_js_1.parseCodepointFromFilename)(a) - (0, parse_js_1.parseCodepointFromFilename)(b));
-    if (files.length === 0)
-        throw new Error(`No glyph SVGs found in: ${glyphDir}`);
-    const fontStream = new SVGIcons2SVGFontStream({
+    if (glyphs.length === 0)
+        throw new Error('No glyphs to compile');
+    const svgFontString = buildSvgFontXml({
         fontName,
-        fontHeight: upm,
-        normalize: false,
+        glyphs,
+        upm,
         ascent,
         descent,
     });
-    const svgFontChunks = [];
-    fontStream.on('data', (c) => svgFontChunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c)));
-    // Single error listener for the font stream; per-glyph errors are handled in writeGlyphStreamToFont.
-    let fontStreamReject;
-    const fontStreamErrorPromise = new Promise((_, rej) => {
-        fontStreamReject = rej;
-    });
-    fontStream.on('error', (err) => fontStreamReject(err));
-    for (const f of files) {
-        await Promise.race([
-            writeGlyphStreamToFont(fontStream, node_path_1.default.join(glyphDir, f), f),
-            fontStreamErrorPromise,
-        ]);
-    }
-    fontStream.end();
-    await (0, node_events_1.once)(fontStream, 'end');
-    const svgFontString = Buffer.concat(svgFontChunks).toString('utf8');
     const ttfRaw = (0, svg2ttf_1.default)(svgFontString);
     const rawBuf = Buffer.from(ttfRaw.buffer);
     const fixedBuf = (0, metrics_js_1.forceTtfMetrics)(rawBuf, upm, ascent, descent, lineGap);

package/lib/commonjs/src/core/pipeline/managers.js

@@ -56,14 +56,30 @@ class PyodideManager {
         const pathopsPy = await promises_1.default.readFile(pathopsPyPath, 'utf8');
         py.FS.writeFile('/pathops.py', pathopsPy);
         await py.loadPackage(['micropip', 'lxml'], { messageCallback: () => { } });
+        // Resolve local picosvg wheel path for offline-first installation.
+        const picosvgWhlDir = node_path_1.default.join(getPackageRoot(), 'src', 'core', 'shims');
+        const picosvgWhl = (await promises_1.default.readdir(picosvgWhlDir))
+            .find((f) => f.startsWith('picosvg-') && f.endsWith('.whl'));
+        const localWhlUrl = picosvgWhl
+            ? `file://${node_path_1.default.join(picosvgWhlDir, picosvgWhl)}`
+            : null;
+        py.globals.set('_picosvg_local_whl', localWhlUrl);
         await py.runPythonAsync(`
       import sys
       if "/" not in sys.path:
           sys.path.insert(0, "/")
-          
+
       import micropip
-      await micropip.install("picosvg", deps=False)
-          
+
+      _whl = _picosvg_local_whl
+      if _whl:
+          try:
+              await micropip.install(_whl, deps=False)
+          except Exception:
+              await micropip.install("picosvg", deps=False)
+      else:
+          await micropip.install("picosvg", deps=False)
+
       import pathops
       import picosvg
     `);

package/lib/commonjs/src/core/pipeline/run.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runPipeline = runPipeline;
-const node_fs_1 = __importDefault(require("node:fs"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const compile_js_1 = require("../font/compile.js");
@@ -12,6 +11,64 @@ const managers_js_1 = require("./managers.js");
 const config_js_1 = require("./config.js");
 const svg_dom_js_1 = require("../svg/svg_dom.js");
 const layers_js_1 = require("../svg/layers.js");
+const svg_pathops_js_1 = require("../svg/svg_pathops.js");
+/**
+ * Concatenate multiple SVG path `d` strings into a single compound path.
+ * This preserves the exact geometry of each path (no boolean operations)
+ * while combining them into one glyph. Under nonzero winding, this renders
+ * identically to drawing each path separately with the same color.
+ */
+function concatPathDs(ds) {
+    if (ds.length === 0)
+        return null;
+    if (ds.length === 1)
+        return ds[0];
+    return ds.join(' ');
+}
+/**
+ * Merge consecutive same-color paths into single compound paths via boolean UNION.
+ * Preserves z-order: only merges runs of adjacent paths with identical fill color.
+ */
+function mergeSameColorPaths(paths, logger) {
+    if (paths.length <= 1)
+        return paths;
+    const result = [];
+    let i = 0;
+    while (i < paths.length) {
+        const fill = paths[i].fill;
+        // Find consecutive run of same fill that are all mergeable.
+        // Paths converted from evenodd have compound hole structure and must not
+        // be merged — their CW hole contours would cancel CCW contours from
+        // adjacent paths, producing incorrect fill.
+        let j = i + 1;
+        if (!paths[i].noMerge) {
+            while (j < paths.length &&
+                paths[j].fill === fill &&
+                !paths[j].noMerge) {
+                j++;
+            }
+        }
+        if (j - i === 1) {
+            result.push(paths[i]);
+        }
+        else {
+            const group = paths.slice(i, j);
+            const merged = concatPathDs(group.map((p) => p.d));
+            if (merged) {
+                logger?.info(`    ⊕ Merged ${group.length} same-color paths (fill=${fill})`);
+                result.push({ d: merged, fill });
+            }
+            else {
+                result.push(...group);
+            }
+        }
+        i = j;
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Pipeline
+// ---------------------------------------------------------------------------
 /**
  * Run the font pipeline with given config and paths.
  * Uses the singleton Pyodide/PathKit instance (initialized on first call).
@@ -20,19 +77,21 @@ async function runPipeline(config, paths, options) {
     const startTime = Date.now();
     const logger = options?.logger;
     logger?.update(`Building "${config.fontFamily}"…`);
-    (0, config_js_1.ensureEmptyDir)(paths.tempDir);
     (0, config_js_1.ensureDir)(paths.outputDir);
     const files = (await promises_1.default.readdir(paths.inputDir)).filter((f) => f.toLowerCase().endsWith('.svg'));
     const glyphMap = {
-        meta: {
-            fontFamily: config.fontFamily,
-            upm: config.upm,
-            safeZone: config.safeZone,
-            startUnicode: config.startUnicode,
+        m: {
+            f: config.fontFamily,
+            u: config.upm,
+            z: config.safeZone,
+            s: config.startUnicode,
         },
-        icons: {},
+        i: {},
     };
     let currentUnicode = config.startUnicode;
+    const codepointToIcon = new Map();
+    const allGlyphs = [];
+    const PathKit = await managers_js_1.PathKitManager.getInstance();
     for (const file of files) {
         const iconName = node_path_1.default.parse(file).name;
         const filePath = node_path_1.default.join(paths.inputDir, file);
@@ -44,55 +103,85 @@ async function runPipeline(config, paths, options) {
             continue;
         }
         const preprocessed = (0, svg_dom_js_1.preprocessSvg)(rawContent);
+        // Preserve original evenodd `d` strings BEFORE picosvg processes them.
+        // Picosvg's simplify (via our PathKit shim) can drop contours from
+        // multi-subpath evenodd paths — we restore the originals after.
+        const originalEvenoddDs = (0, svg_dom_js_1.extractOriginalEvenoddDs)(preprocessed);
         const flattenedSvg = await (0, managers_js_1.picoFromFile)(filePath, preprocessed);
-        const parsed = (0, svg_dom_js_1.parseFlattenedSvg)(flattenedSvg);
+        const parsed = (0, svg_dom_js_1.parseFlattenedSvg)(flattenedSvg, {
+            onSanitize: (original) => {
+                logger?.info(`  ⚠ Sanitized path in "${file}": path was missing initial moveto (prepended M from endpoint)`);
+                logger?.info(`    Original: ${original.slice(0, 80)}…`);
+            },
+        });
+        // Restore original evenodd path data (undamaged by picosvg's simplify),
+        // then convert to nonzero winding with our containment-based algorithm.
+        // Mark as noMerge — compound paths with holes must stay separate so their
+        // CW hole contours don't cancel adjacent paths' CCW contours.
+        if (originalEvenoddDs.length > 0) {
+            (0, svg_dom_js_1.restoreOriginalEvenoddDs)(parsed.paths, originalEvenoddDs);
+        }
+        for (const p of parsed.paths) {
+            if (p.fillRule === 'evenodd') {
+                logger?.info(`  ↻ Converting evenodd path to nonzero winding in "${file}"`);
+                p.d = (0, svg_pathops_js_1.convertEvenoddToWinding)(PathKit, p.d);
+                delete p.fillRule;
+                p.noMerge = true;
+            }
+        }
+        // Merge consecutive same-color paths into single compound glyphs
+        const mergedPaths = mergeSameColorPaths(parsed.paths, logger);
         const { vx, vy, scale, xOff, yOff, adv } = (0, layers_js_1.computePlacement)({
             upm: config.upm,
             safeZone: config.safeZone,
             viewBox: parsed.viewBox,
         });
-        const entry = { adv, layers: [] };
-        for (const p of parsed.paths) {
+        const layers = [];
+        for (const p of mergedPaths) {
             if ((0, svg_dom_js_1.shouldSkipPath)(p.d, p.fill))
                 continue;
             const cp = currentUnicode++;
-            await (0, layers_js_1.writeLayerSvg)({
-                tempDir: paths.tempDir,
-                upm: config.upm,
-                adv,
+            codepointToIcon.set(cp, iconName);
+            const fontD = (0, layers_js_1.transformPathForFont)(PathKit, p.d, {
                 vx,
                 vy,
                 scale,
                 xOff,
                 yOff,
-                d: p.d,
+                upm: config.upm,
+            });
+            allGlyphs.push({
                 codepoint: cp,
+                advanceWidth: adv,
+                d: fontD,
             });
-            entry.layers.push({ codepoint: cp, color: p.fill || 'black' });
+            layers.push([cp, p.fill || 'black']);
         }
-        if (entry.layers.length > 0) {
-            glyphMap.icons[iconName] = entry;
+        if (layers.length > 0) {
+            glyphMap.i[iconName] = [adv, layers];
         }
     }
     const glyphmapPath = node_path_1.default.join(paths.outputDir, `${config.fontFamily}.glyphmap.json`);
     if (options?.inputHash) {
-        glyphMap.meta.hash = options.inputHash;
+        glyphMap.m.h = options.inputHash;
     }
-    await promises_1.default.writeFile(glyphmapPath, JSON.stringify(glyphMap, null, 2), 'utf8');
+    await promises_1.default.writeFile(glyphmapPath, JSON.stringify(glyphMap), 'utf8');
     logger?.info(`Compiling TTF…`);
     const ttfPath = node_path_1.default.join(paths.outputDir, `${config.fontFamily}.ttf`);
-    await (0, compile_js_1.compileTtfFromGlyphSVGs)({
-        glyphDir: paths.tempDir,
-        outTtfPath: ttfPath,
-        fontName: config.fontFamily,
-        upm: config.upm,
-        ascent: config.upm,
-        descent: 0,
-    });
-    if (node_fs_1.default.existsSync(paths.tempDir)) {
-        node_fs_1.default.rmSync(paths.tempDir, { recursive: true, force: true });
+    try {
+        await (0, compile_js_1.compileTtfFromGlyphs)({
+            glyphs: allGlyphs,
+            outTtfPath: ttfPath,
+            fontName: config.fontFamily,
+            upm: config.upm,
+            ascent: config.upm,
+            descent: 0,
+        });
+    }
+    catch (err) {
+        (0, compile_js_1.parseCompileTtfFromGlyphsError)(err, codepointToIcon);
     }
-    const iconCount = Object.keys(glyphMap.icons).length;
+    const iconCount = Object.keys(glyphMap.i).length;
     const elapsed = Date.now() - startTime;
     logger?.succeed(`Built ${config.fontFamily}.ttf [${iconCount} icon${iconCount === 1 ? '' : 's'} in ${elapsed}ms]`);
     return { ttfPath, glyphmapPath };

package/lib/commonjs/src/core/svg/layers.d.ts

@@ -1,3 +1,4 @@
+import type { PathKitModule } from '../types.js';
 export declare function computePlacement(opts: {
     upm: number;
     safeZone: number;
@@ -22,3 +23,18 @@ export declare function writeLayerSvg(opts: {
     d: string;
     codepoint: number;
 }): Promise<void>;
+/**
+ * Transform an SVG path `d` string from source SVG coordinates into font
+ * glyph coordinates (Y-up, with placement scaling and centering applied).
+ *
+ * Combines placement transform (translate + scale + translate) with the
+ * SVG→font Y-axis flip into a single affine transform applied via PathKit.
+ */
+export declare function transformPathForFont(PathKit: PathKitModule, d: string, opts: {
+    vx: number;
+    vy: number;
+    scale: number;
+    xOff: number;
+    yOff: number;
+    upm: number;
+}): string;

package/lib/commonjs/src/core/svg/layers.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computePlacement = computePlacement;
 exports.writeLayerSvg = writeLayerSvg;
+exports.transformPathForFont = transformPathForFont;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 function roundInt(n) {
@@ -40,3 +41,29 @@ async function writeLayerSvg(opts) {
     </svg>`.trim();
     await promises_1.default.writeFile(node_path_1.default.join(opts.tempDir, `u${hex}.svg`), layerSvg, 'utf8');
 }
+/**
+ * Transform an SVG path `d` string from source SVG coordinates into font
+ * glyph coordinates (Y-up, with placement scaling and centering applied).
+ *
+ * Combines placement transform (translate + scale + translate) with the
+ * SVG→font Y-axis flip into a single affine transform applied via PathKit.
+ */
+function transformPathForFont(PathKit, d, opts) {
+    const { vx, vy, scale, xOff, yOff, upm } = opts;
+    const p = PathKit.FromSVGString(d);
+    if (!p)
+        return d;
+    // Combined affine: placement + Y-flip for font coordinates.
+    //   x' =  scale * (x - vx) + xOff
+    //   y' =  upm - (scale * (y - vy) + yOff)
+    //
+    // SkMatrix row-major: [scaleX, skewX, transX, skewY, scaleY, transY, 0,0,1]
+    const scaleX = scale;
+    const scaleY = -scale;
+    const transX = xOff - vx * scale;
+    const transY = upm - yOff + vy * scale;
+    p.transform(scaleX, 0, transX, 0, scaleY, transY, 0, 0, 1);
+    const result = p.toSVGString();
+    p.delete?.();
+    return result;
+}

package/lib/commonjs/src/core/svg/svg_dom.d.ts

@@ -3,14 +3,27 @@ export type ParsedFlatSvg = {
     paths: Array<{
         d: string;
         fill: string | null;
+        fillRule?: 'evenodd';
     }>;
 };
 export declare function calculateOpColor(fill: string | null, opacity: number, el: Element): `rgba(${number},${number},${number},${number})`;
+/**
+ * If a flattened path lost its initial moveto (e.g. picosvg dropped an empty
+ * `Mx y z` subpath), prepend `M` using the path's last coordinate pair.
+ * For closed icon shapes the endpoint equals the start point.
+ */
+export declare function sanitizePathData(d: string): {
+    d: string;
+    sanitized: boolean;
+};
 export declare const parsePath: (p: Element) => {
     d: string;
     fill: string | null;
+    fillRule?: "evenodd";
 };
-export declare function parseFlattenedSvg(flattenedSvg: string): ParsedFlatSvg;
+export declare function parseFlattenedSvg(flattenedSvg: string, options?: {
+    onSanitize?: (original: string) => void;
+}): ParsedFlatSvg;
 export declare function shouldSkipPath(d: string, fill: string | null): boolean;
 export type SvgValidation = {
     valid: true;
@@ -19,4 +32,19 @@ export type SvgValidation = {
     reason: string;
 };
 export declare function validateSvg(content: string): SvgValidation;
+/**
+ * Extract the original `d` strings of evenodd paths from the raw SVG
+ * BEFORE picosvg processes it. Picosvg's simplify (via our PathKit shim)
+ * can drop contours from multi-subpath evenodd paths, so we preserve
+ * the originals and apply our own winding conversion later.
+ *
+ * Returns one `d` string per evenodd path, in document order.
+ */
+export declare function extractOriginalEvenoddDs(svgContent: string): string[];
+/**
+ * Replace picosvg's (potentially damaged) evenodd path data with the
+ * preserved originals. Matches by position: the Nth evenodd path in
+ * the parsed output gets the Nth original `d` string.
+ */
+export declare function restoreOriginalEvenoddDs(paths: ParsedFlatSvg['paths'], originalDs: string[]): void;
 export declare function preprocessSvg(content: string): string;