sf-symbols-svg 6.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Maxime Thirouin
+
+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,189 @@
+# SF Symbols to SVG
+
+<a href="https://github.com/MoOx/sf-symbols-svg?sponsor=1">
+  <img width="140" align="right" alt="Sponsoring button" src="https://github.com/moox/.github/raw/main/FUNDING.svg">
+</a>
+
+[![GitHub package.json version](https://img.shields.io/github/package-json/v/MoOx/sf-symbols-svg) ![npm downloads](https://img.shields.io/npm/dm/sf-symbols-svg)](https://www.npmjs.com/package/sf-symbols-svg)
+[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/MoOx/sf-symbols-svg/build.yml?branch=main)](https://github.com/MoOx/sf-symbols-svg/actions)
+[![License](https://img.shields.io/github/license/MoOx/sf-symbols-svg)](https://github.com/MoOx/sf-symbols-svg)  
+![My website moox.io](https://img.shields.io/badge/%F0%9F%8C%8D%20-https%3A%2F%2Fmoox.io-gray?style=social)
+[![GitHub followers](https://img.shields.io/github/followers/MoOx?style=social&label=GitHub)](https://github.com/MoOx)
+[![LinkedIn Follow](https://img.shields.io/badge/LinkedIn-%20?style=social&logo=invision&logoColor=%230077B5)](https://www.linkedin.com/in/maxthirouin/)
+[![BlueSky Follow](https://img.shields.io/badge/BlueSky-%20?style=social&logo=bluesky)](https://bsky.app/profile/moox.io)
+[![X Follow](https://img.shields.io/twitter/follow/MoOx?style=social&label=)](https://x.com/MoOx)
+
+> SF Symbols to SVGs. Period.
+
+[Apple SF Symbols](https://developer.apple.com/sf-symbols/) is an icon set with more thant 6,000 symbols.
+Unfortunately, this are not available on the web.
+This tool solve this.
+
+> [!WARNING]
+> This tool requires you to have the [_SF Pro Text_ font](https://developer.apple.com/fonts/) installed on your system or in a custom directory.
+
+> [!TIP]
+> SF Symbols to SVG can be coupled with [React from SVG](https://github.com/MoOx/react-from-svg) to generate React components from SVGs.
+
+## Usage
+
+SF Symbols to SVG is available as a CLI tool:
+
+```console
+npx sf-symbols-svg --help
+```
+
+#### Available Options
+
+```console
+--size, -s       Font size for symbols (default: 24)
+--padding, -p    Padding in pixels (default: 2)
+--weight, -w     Font weights to include (default: regular)
+                 Can specify multiple: -w regular -w bold
+--output, -o     Output directory (default: ./sf-symbols-svgs)
+--fonts-dir, -f  Directory containing SF Pro Text fonts (default: /Library/Fonts)
+--sf-version     SF Symbols version to use (default: latest)
+--sources-dir    Directory containing SF Symbols data files (default: ./sources)
+--icons-list     Path to a file containing a list of icons to process, one name per line (optional)
+--help, -h       Show this help message
+--version        Show version of SF Symbols supported by this tool.
+```
+
+> [!NOTE]
+> SF Symbols to SVG will always try to use the latest version of SF Symbols supported by this tool.
+> You can check in the `sources/` directory to see which versions are supported.
+
+#### Examples
+
+```console
+# Generate SVGs for the latest version of SF Symbols, in 24x24 SVGs with 2px padding, in ./svg-symbols-svgs folder
+npx sf-symbols-svg --weight all
+
+# Generate SVGs with larger size and padding
+sf-symbols-svg --size 32 --padding 4
+
+# Generate SVGs for multiple weights
+sf-symbols-svg --weight bold --weight black
+
+# Specify custom output directory
+sf-symbols-svg --output ./my-icons
+
+# Specify a different SF Symbols version (if available)
+sf-symbols-svg --sf-version 6.0
+
+# Combine options
+sf-symbols-svg --size 48 --padding 8 --weight light --weight regular --weight bold --output ./custom-icons --fonts-dir /Users/moox/Library/Fonts
+
+# Process only specific icons
+sf-symbols-svg --icons-list /path/to/your/icons-list.txt
+```
+
+## Creating a new version
+
+## About SF Symbols Versions and Font Compatibility
+
+### SF Symbols Versions
+
+This tool automatically detects supported SF Symbols versions by scanning the `sources/` directory. Each version requires its own data files (`symbols.txt` and `names.txt`) which are already included in the repository for some versions.
+
+The tool will automatically use the most recent version as the default, but you can specify a different version using the `--sf-version` option. If no matching versions are detected in the `sources/` directory, the tool will display an error message.
+
+If you want to use a different version (when new SF Symbols versions are released):
+
+1. Create a new directory in `sources/{version}/` (example: `sources/7.0/`)
+2. Extract the character mappings:
+   - Get the [SF Symbols app](https://developer.apple.com/sf-symbols/) and open the app
+   - Select all symbols (`cmd + A` or `Edit` > `Select All`)
+   - Right click on the selection, and press `Copy all {x} symbols`
+   - Paste the symbols into a file at `sources/{version}/symbols.txt`
+   - Right click again on the selection, and press `Copy all {x} names`
+   - Paste the names into a file at `sources/{version}/names.txt`
+
+That's it! The tool will automatically detect the new version and use it as the default (since it's the most recent).
+
+### Using a Custom Sources Directory
+
+If you want to use a different directory for your SF Symbols data files, you can specify it with the `--sources-dir` option:
+
+```sh
+sf-symbols-svg --sources-dir /path/to/your/sources
+```
+
+The custom sources directory must follow the same structure as the default one:
+
+```
+sources/
+  ├── 6.0/
+  │   ├── symbols.txt
+  │   └── names.txt
+  ├── 6.1/
+  │   ├── symbols.txt
+  │   └── names.txt
+  └── ...
+```
+
+The tool will automatically detect available versions from the provided directory and use the most recent one as the default.
+
+## Processing Only Specific Icons
+
+If you want to process only a limited subset of icons, you can create a text file with one icon name per line and use the `--icons-list` option:
+
+```sh
+sf-symbols-svg --icons-list /path/to/your/icons-list.txt
+```
+
+Example of an icons list file:
+
+```
+moon.stars.fill
+puzzlepiece
+amplifier
+figure.hiking
+```
+
+This is particularly useful for:
+
+- Testing the tool with a smaller set of icons
+- Generating only the specific icons you need for your project
+- Reducing processing time when you only need a few symbols
+
+### Font Compatibility
+
+> [!WARNING] SF Symbols requires specific _SF Pro Text_ font versions that match the SF Symbols version you're using. If the font versions don't match, the symbols may not render correctly.
+
+> [!CAUTION]
+> The Apple SF Symbols app will display a warning at the top of the application if your installed fonts don't match the expected version. Make sure to check this warning and install the appropriate font version from [Apple's website](https://developer.apple.com/fonts/).
+
+### About Font Files
+
+To use this script, you need to have the SF Pro Text fonts installed on your system or in a custom directory.
+
+#### Using system-installed fonts (recommended)
+
+If you have SF Pro Text fonts installed on your system (typically in `/Library/Fonts`), the script will automatically find and use them. This is the default behavior.
+
+````console
+# Use fonts from the default location (/Library/Fonts)
+sf-symbols-svg`
+
+#### Using fonts from a custom directory
+
+If your fonts are installed in a different location, you can specify it with the `--fonts-dir` option:
+
+```console
+# Use fonts from a custom location
+sf-symbols-svg --fonts-dir ~/Library/Fonts
+````
+
+#### Installing SF Pro Text fonts
+
+If you don't have the fonts installed:
+
+1. Download SF Pro font from [Apple's website](https://developer.apple.com/fonts/).
+2. Install the font using the provided installer.
+3. The fonts will be installed in `/Library/Fonts` by default.
+
+---
+
+> [!NOTE]
+> For legal reasons, this repository does not include the SF Pro Text font files. You must download and install them from Apple's website. Make sure to use font versions that are compatible with the SF Symbols version you are using (check for warnings in the SF Symbols app).

package/dist/index.js

@@ -0,0 +1,449 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import opentype from "opentype.js";
+import meow from "meow";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PATH_PRECISION = 2;
+/**
+ * Default sources directory path
+ */
+const DEFAULT_SOURCES_DIR = path.join(__dirname, "../sources");
+/**
+ * Detects available versions based on folders in the sources directory
+ * @param {string} sourcesDir - Path to the sources directory
+ * @throws {Error} If no version is detected
+ */
+function detectAvailableVersions(sourcesDir) {
+    try {
+        const items = fs.readdirSync(sourcesDir, { withFileTypes: true });
+        const versions = items
+            .filter((item) => item.isDirectory() && !item.name.startsWith("."))
+            .map((item) => item.name)
+            // Sort versions in descending order (to have the most recent first)
+            .sort((a, b) => {
+            // Semantic version comparison (e.g., "6.1" > "6.0")
+            const partsA = a.split(".").map(Number);
+            const partsB = b.split(".").map(Number);
+            for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+                const partA = partsA[i] || 0;
+                const partB = partsB[i] || 0;
+                if (partA !== partB) {
+                    return partB - partA; // Descending order
+                }
+            }
+            return 0;
+        });
+        if (versions.length === 0) {
+            throw new Error(`No SF Symbols version detected in the sources directory. Please add at least one version folder containing symbols.txt and names.txt files.`);
+        }
+        return versions;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw error; // Propagate the error if it's already an Error instance
+        }
+        else {
+            throw new Error(`Error detecting versions: ${error}`);
+        }
+    }
+}
+/**
+ * Get available versions from the default sources directory
+ * This is used only for CLI default values
+ */
+function getDefaultVersions() {
+    try {
+        return detectAvailableVersions(DEFAULT_SOURCES_DIR);
+    }
+    catch (error) {
+        // Return empty array if no versions are detected in the default directory
+        return [];
+    }
+}
+/**
+ * Available SF Symbols versions from default sources (automatically detected)
+ */
+const AVAILABLE_VERSIONS = getDefaultVersions();
+/**
+ * Default version (the most recent one, or empty string if no versions are available)
+ */
+const DEFAULT_VERSION = AVAILABLE_VERSIONS.length > 0 ? AVAILABLE_VERSIONS[0] : "";
+/**
+ * Builds paths to data files for a specific version
+ * @param {string} version - SF Symbols version
+ * @param {string} sourcesDir - Path to the sources directory
+ */
+function getVersionPaths(version, sourcesDir) {
+    return {
+        symbols: path.join(sourcesDir, `${version}/symbols.txt`),
+        names: path.join(sourcesDir, `${version}/names.txt`),
+    };
+}
+/**
+ * Builds file paths based on the output directory, version, and sources directory
+ */
+function buildPaths(outputDir, version, sourcesDir) {
+    const versionPaths = getVersionPaths(version, sourcesDir);
+    return {
+        SYMBOLS: versionPaths.symbols,
+        NAMES: versionPaths.names,
+        SVG_OUTPUT: outputDir,
+    };
+}
+/**
+ * Checks if data files exist for a specific version
+ */
+function checkDataFilesExist(version, sourcesDir) {
+    const paths = getVersionPaths(version, sourcesDir);
+    if (!fileExists(paths.symbols)) {
+        console.error(`symbols.txt file not found: ${paths.symbols}`);
+        return false;
+    }
+    if (!fileExists(paths.names)) {
+        console.error(`names.txt file not found: ${paths.names}`);
+        return false;
+    }
+    return true;
+}
+/**
+ * Writes a file to the filesystem, creating directories if needed
+ */
+function writeFile(filePath, contents) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, contents);
+}
+/**
+ * Generates an SVG from a font character
+ */
+function generateSymbolSvg(font, char, name, options) {
+    try {
+        const { fontSize, padding } = options;
+        const glyphIndex = font.charToGlyphIndex(char);
+        if (glyphIndex === 0)
+            return null;
+        const glyph = font.glyphs.get(glyphIndex);
+        if (!glyph)
+            return null;
+        const path = font.getPath(char, 0, 0, fontSize);
+        if (!path)
+            return null;
+        const bbox = path.getBoundingBox();
+        if (!bbox)
+            return null;
+        const symbolWidth = bbox.x2 - bbox.x1;
+        const symbolHeight = bbox.y2 - bbox.y1;
+        const availableWidth = fontSize - padding * 2;
+        const availableHeight = fontSize - padding * 2;
+        // Calculate the scale needed for the symbol to fit in the available area
+        // taking into account padding on all sides
+        let scale;
+        if (symbolWidth / availableWidth > symbolHeight / availableHeight) {
+            scale = availableWidth / symbolWidth;
+        }
+        else {
+            scale = availableHeight / symbolHeight;
+        }
+        const scaledWidth = symbolWidth * scale;
+        const scaledHeight = symbolHeight * scale;
+        // Calculate translations needed to center the symbol in the viewBox
+        const translateX = (fontSize - scaledWidth) / 2 - bbox.x1 * scale;
+        const translateY = (fontSize - scaledHeight) / 2 - bbox.y1 * scale;
+        const transformMatrix = [scale, 0, 0, scale, translateX, translateY];
+        const pathElement = path.toSVG(PATH_PRECISION);
+        const dMatch = pathElement.match(/d="([^"]*)"/i);
+        if (!dMatch)
+            return null;
+        const dContent = dMatch[1];
+        return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${fontSize} ${fontSize}" width="${fontSize}" height="${fontSize}">
+  <title>${name}</title>
+  <path transform="matrix(${transformMatrix.join(", ")})" d="${dContent}" fill="currentColor"/>
+</svg>`;
+    }
+    catch (error) {
+        console.error(`Error generating SVG for ${name}:`, error);
+        return null;
+    }
+}
+/**
+ * Creates a safe filename from a symbol name
+ */
+function createSafeFilename(name) {
+    return name.replace(/[^a-z0-9\.]/gi, "_").toLowerCase();
+}
+/**
+ * Creates a filename for an SVG with appropriate weight suffix
+ */
+function createSvgFilename(name, weight) {
+    const safeName = createSafeFilename(name);
+    if (weight === "regular") {
+        return `${safeName}.svg`;
+    }
+    return `${safeName}-${weight}.svg`;
+}
+/**
+ * Checks if a file exists
+ */
+function fileExists(filePath) {
+    try {
+        return fs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Finds the font file in the fonts directory
+ */
+function findFontFile(fontsDir, weight) {
+    // Expected format for SF Pro Text
+    const fontName = `SF-Pro-Text-${weight.charAt(0).toUpperCase() + weight.slice(1)}.otf`;
+    const fontPath = path.join(fontsDir, fontName);
+    // Check if the file exists
+    if (fileExists(fontPath)) {
+        return fontPath;
+    }
+    return null;
+}
+/**
+ * Main function to generate SVG files directly from font files
+ */
+async function makeSvgs(options) {
+    const { fontSize = 24, padding = 2, weights = ["regular"], outputDir: outputDirOption = path.join(process.cwd(), "sf-symbols-svgs"), fontsDir: fontsDirOption = "/Library/Fonts", version: versionOption = DEFAULT_VERSION, sourcesDir: sourcesDirOption = DEFAULT_SOURCES_DIR, iconsListFile: iconsListFileOption, } = options || {};
+    const fontsDir = String(fontsDirOption);
+    const outputDir = String(outputDirOption);
+    const sourcesDir = String(sourcesDirOption);
+    let availableVersions;
+    try {
+        availableVersions = detectAvailableVersions(sourcesDir);
+    }
+    catch (error) {
+        throw new Error(`No SF Symbols versions detected in ${sourcesDir}. Please provide a valid sources directory containing version folders with symbols.txt and names.txt files.`);
+    }
+    const version = versionOption ? String(versionOption) : availableVersions[0];
+    if (!fontsDir) {
+        throw new Error("fonts-dir option is required. Please specify the directory containing SF Pro Text fonts.");
+    }
+    try {
+        const versionStr = String(version);
+        const sourcesStr = String(sourcesDir);
+        const sourcesVersionDir = path.join(sourcesStr, versionStr);
+        const stats = fs.statSync(sourcesVersionDir);
+        if (!stats.isDirectory()) {
+            throw new Error(`${sourcesVersionDir} is not a directory`);
+        }
+    }
+    catch (error) {
+        throw new Error(`SF Symbols version '${version}' not found in ${sourcesDir}. Please make sure the directory exists and contains the required data files.`);
+    }
+    if (!checkDataFilesExist(String(version), sourcesDir)) {
+        throw new Error(`Data files for SF Symbols ${version} are missing in ${sourcesDir}/${version}/. Please check the README for setup instructions.`);
+    }
+    const PATHS = buildPaths(outputDir, String(version), sourcesDir);
+    console.log("Loading Fonts...");
+    const fonts = await Promise.all(weights.map(async (weight) => {
+        try {
+            const fontPath = findFontFile(fontsDir, weight);
+            if (!fontPath) {
+                console.error(`Font file for weight '${weight}' not found in ${fontsDir}`);
+                console.error(`Please make sure SF-Pro-Text-${weight.charAt(0).toUpperCase() + weight.slice(1)}.otf is installed in the specified fonts directory.`);
+                return null;
+            }
+            console.log(`Loading font: ${fontPath}`);
+            const font = await opentype.load(fontPath);
+            return { weight, font };
+        }
+        catch (error) {
+            console.error(`Error loading font weight ${weight}:`, error);
+            return null;
+        }
+    }));
+    const validFonts = fonts.filter((item) => !!item);
+    if (validFonts.length === 0) {
+        throw new Error("No valid fonts were loaded. Please check the weights and font files.");
+    }
+    console.log(`Fonts loaded: ${validFonts.map((f) => f.weight).join(", ")}`);
+    console.log("Capturing Paths... This takes a while");
+    let symbolsData = fs
+        .readFileSync(PATHS.SYMBOLS, { encoding: "utf-8" })
+        .match(/.{1,2}/g)
+        ?.filter((char) => char !== "") || [];
+    let names = fs
+        .readFileSync(PATHS.NAMES, { encoding: "utf8", flag: "r" })
+        .split(/\r?\n/)
+        .filter((char) => char !== "");
+    if (iconsListFileOption) {
+        try {
+            const iconsList = fs
+                .readFileSync(String(iconsListFileOption), {
+                encoding: "utf8",
+                flag: "r",
+            })
+                .split(/\r?\n/)
+                .filter((name) => name !== "");
+            if (iconsList.length === 0) {
+                console.warn(`Icons list file ${iconsListFileOption} is empty. Using all available icons.`);
+            }
+            else {
+                const filteredNamesIndices = [];
+                const filteredNames = [];
+                const filteredSymbols = [];
+                for (const iconName of iconsList) {
+                    const index = names.indexOf(iconName);
+                    if (index !== -1) {
+                        filteredNamesIndices.push(index);
+                        filteredNames.push(iconName);
+                        if (index < symbolsData.length) {
+                            const charItem = symbolsData[index];
+                            if (charItem) {
+                                filteredSymbols.push(charItem);
+                            }
+                        }
+                    }
+                    else {
+                        console.warn(`Icon '${iconName}' not found in available icons.`);
+                    }
+                }
+                if (filteredNames.length === 0) {
+                    console.warn("None of the specified icons were found. Using all available icons.");
+                }
+                else {
+                    console.log(`Processing ${filteredNames.length} icons from list file.`);
+                    names = filteredNames;
+                    symbolsData = filteredSymbols;
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error reading icons list file: ${error}`);
+            console.warn("Using all available icons.");
+        }
+    }
+    console.log(`Output directory: ${outputDir}`);
+    fs.mkdirSync(PATHS.SVG_OUTPUT, { recursive: true });
+    for (let namesIndex = 0; namesIndex < names.length; namesIndex++) {
+        const name = names[namesIndex];
+        if (!name)
+            continue;
+        console.log(`${namesIndex + 1}/${names.length} - ${name}`);
+        const char = symbolsData[namesIndex];
+        if (!char)
+            continue;
+        for (const { weight, font } of validFonts) {
+            const svgContent = generateSymbolSvg(font, char, name, {
+                fontSize,
+                padding,
+            });
+            if (!svgContent)
+                continue;
+            const svgFilename = createSvgFilename(name, weight);
+            const svgPath = path.join(PATHS.SVG_OUTPUT, svgFilename);
+            writeFile(svgPath, svgContent);
+        }
+    }
+    console.log("Done! Generated SVG files in", PATHS.SVG_OUTPUT);
+}
+const cli = meow(`
+  Usage
+    $ sf-symbols-svg [options]
+
+  Options
+    --size, -s       Font size for symbols (default: 24)
+    --padding, -p    Padding in pixels (default: 2)
+    --weight, -w     Font weights to include (default: regular)
+                     Can specify multiple: -w regular -w bold
+                     Special value "all" to include all available weights
+    --output, -o     Output directory (default: ./sf-symbols-svgs)
+    --fonts-dir, -f  Directory containing SF Pro Text fonts (default: /Library/Fonts)
+    --sf-version     SF Symbols version to use (default: latest)
+    --sources-dir    Directory containing SF Symbols data files (default: ./sources)
+    --icons-list     Path to a file containing a list of icons to process, one name per line (optional)
+    --help, -h       Show this help message
+    --version        Show version
+
+  Examples
+    $ sf-symbols-svg
+    $ sf-symbols-svg --size 32 --padding 4
+    $ sf-symbols-svg --weight bold --weight black
+    $ sf-symbols-svg --weight all
+    $ sf-symbols-svg --output ./my-icons
+    $ sf-symbols-svg --fonts-dir ~/Library/Fonts
+    $ sf-symbols-svg --sf-version 6.0
+`, {
+    importMeta: import.meta,
+    flags: {
+        size: {
+            type: "number",
+            default: 24,
+            shortFlag: "s",
+        },
+        padding: {
+            type: "number",
+            default: 2,
+            shortFlag: "p",
+        },
+        weight: {
+            type: "string",
+            default: ["regular"],
+            isMultiple: true,
+            shortFlag: "w",
+        },
+        output: {
+            type: "string",
+            shortFlag: "o",
+        },
+        fontsDir: {
+            type: "string",
+            shortFlag: "f",
+        },
+        sfVersion: {
+            type: "string",
+        },
+        sourcesDir: {
+            type: "string",
+            description: "Directory containing SF Symbols data files",
+        },
+        iconsList: {
+            type: "string",
+            description: "Path to a file containing a list of icons to process (one per line)",
+        },
+        help: {
+            type: "boolean",
+            shortFlag: "h",
+        },
+    },
+});
+/**
+ * Available font weights
+ */
+const FONT_WEIGHTS = [
+    "thin",
+    "ultraLight",
+    "light",
+    "regular",
+    "medium",
+    "semibold",
+    "bold",
+    "heavy",
+    "black",
+];
+// Process weights option - handle "all" special value
+let weights = cli.flags.weight;
+if (weights.length === 1 && weights[0].toLowerCase() === "all") {
+    weights = FONT_WEIGHTS;
+    console.log(`Using all available weights: ${weights.join(", ")}`);
+}
+makeSvgs({
+    fontSize: cli.flags.size,
+    padding: cli.flags.padding,
+    weights: weights,
+    outputDir: cli.flags.output,
+    fontsDir: cli.flags.fontsDir,
+    version: cli.flags.sfVersion,
+    sourcesDir: cli.flags.sourcesDir,
+    iconsListFile: cli.flags.iconsList,
+}).catch((error) => {
+    console.error("Error generating SVGs:", error);
+    process.exit(1);
+});