@iconoma/studio 0.0.0

package/README.md

@@ -0,0 +1,9 @@
+# Iconoma Studio!
+
+This is the Iconoma Studio, if you want to use Iconoma go to [https://github.com/Theryston/iconoma](https://github.com/Theryston/iconoma). But to start Iconoma Studio programmatically:
+
+```ts
+import { createServer } from "@iconoma/studio";
+
+const { url, close } = await createServer({ port });
+```

package/dist/api/actions.d.ts

@@ -0,0 +1,7 @@
+import { Table } from "./db.js";
+import { ActionModel } from "./types.js";
+export declare function actionsWorker({ actionId, table, }: {
+    actionId: number;
+    table: Table<ActionModel>;
+}): Promise<void | import("./types.js").LockFileIcon>;
+//# sourceMappingURL=actions.d.ts.map

package/dist/api/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../api/actions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAmBtC,wBAAsB,aAAa,CAAC,EAClC,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;CAC3B,kDAuDA"}

package/dist/api/actions.js

@@ -0,0 +1,351 @@
+import { getIconContent, getLockFile, getPwd, setLockFile, getConfig, createAction, setContent, } from "./utils.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import crypto from "node:crypto";
+import { optimize } from "svgo";
+import { ReactTargetClient } from "./target-clients/react.js";
+import { ReactNativeTargetClient } from "./target-clients/react-native.js";
+import { mapColors } from "./svgo-plugin-map-colors.js";
+export async function actionsWorker({ actionId, table, }) {
+    const action = table.get(actionId);
+    if (!action)
+        return;
+    try {
+        let output = null;
+        switch (action.type) {
+            case "MIGRATE_SVG_TO_LOCK":
+                output = await migrateSvgToLock(action.filePath, action.metadata && "iconKey" in action.metadata
+                    ? action.metadata
+                    : undefined);
+                break;
+            case "MIGRATE_SVG_TO_FILE":
+                output = await migrateSvgToFile(action.filePath, action.iconKey);
+                break;
+            case "ADD_EXTRA_TARGET":
+                output = await addExtraTarget(action);
+                break;
+            case "REMOVE_EXTRA_TARGET":
+                output = await removeExtraTarget(action);
+                break;
+            case "CREATE_ICON":
+                output = await createIcon(action);
+                break;
+            case "REMOVE_ICON":
+                output = await removeIcon(action);
+                break;
+            case "REGENERATE_ICON":
+                output = await regenerateIcon(action);
+                break;
+            case "REGENERATE_ALL":
+                output = await regenerateAll(action, actionId, table);
+                break;
+        }
+        table.update(actionId, {
+            ...action,
+            status: "completed",
+            percentage: 100,
+        });
+        return output;
+    }
+    catch (error) {
+        console.error(error);
+        table.update(actionId, {
+            ...action,
+            status: "failed",
+            error: error instanceof Error ? error.message : "Unknown error",
+        });
+    }
+}
+async function removeExtraTarget(action) {
+    const lockFile = await getLockFile();
+    if (!lockFile)
+        throw new Error(`Lock file not found`);
+    const icon = lockFile.icons[action.iconKey];
+    if (!icon)
+        throw new Error(`Icon ${action.iconKey} not found in lock file`);
+    let targetClient;
+    switch (action.targetId) {
+        case "react":
+            targetClient = new ReactTargetClient();
+            break;
+        case "react-native":
+            targetClient = new ReactNativeTargetClient();
+            break;
+    }
+    if (!targetClient)
+        throw new Error(`Target client not found`);
+    await targetClient.removeIcon(icon, action.iconKey, action.filePath);
+    delete icon.targets[action.targetId];
+    lockFile.icons[action.iconKey] = icon;
+    await setLockFile(lockFile);
+    console.log(`Removed target ${action.targetId} for ${action.iconKey}`);
+}
+async function addExtraTarget(action) {
+    const lockFile = await getLockFile();
+    if (!lockFile)
+        throw new Error(`Lock file not found`);
+    const icon = lockFile.icons[action.iconKey];
+    if (!icon)
+        throw new Error(`Icon ${action.iconKey} not found in lock file`);
+    let targetClient;
+    switch (action.targetId) {
+        case "react":
+            targetClient = new ReactTargetClient();
+            break;
+        case "react-native":
+            targetClient = new ReactNativeTargetClient();
+            break;
+    }
+    if (!targetClient)
+        throw new Error(`Target client not found`);
+    await targetClient.addIcon(icon, action.iconKey, action.filePath);
+    icon.targets[action.targetId] = {
+        path: action.filePath,
+        builtFrom: {
+            svgHash: icon.svg.hash,
+            configHash: lockFile.configHash,
+        },
+    };
+    lockFile.icons[action.iconKey] = icon;
+    await setLockFile(lockFile);
+    console.log(`Added target ${action.targetId} for ${action.iconKey}`);
+}
+async function migrateSvgToLock(filePath, metadata) {
+    if (!filePath || !metadata?.iconKey)
+        return;
+    const lockFile = await getLockFile();
+    if (!lockFile)
+        return;
+    const icon = lockFile.icons[metadata.iconKey];
+    if (!icon)
+        return;
+    const pwd = await getPwd();
+    const fullPath = path.join(pwd, filePath);
+    const exists = await fs
+        .access(fullPath)
+        .then(() => true)
+        .catch(() => false);
+    if (!exists)
+        throw new Error(`File ${fullPath} does not exist`);
+    const content = await getIconContent(icon);
+    if (icon.svg.content !== content) {
+        icon.svg.content = content;
+        icon.svg.hash = crypto.createHash("sha256").update(content).digest("hex");
+        lockFile.icons[metadata.iconKey] = icon;
+        await setLockFile(lockFile);
+    }
+    else {
+        console.log(`SVG for ${metadata.iconKey} is already in lock`);
+    }
+    await fs.unlink(fullPath);
+    const folder = path.dirname(fullPath);
+    const files = await fs.readdir(folder);
+    if (files.length === 0) {
+        await fs.rmdir(folder);
+        console.log(`Deleted folder ${folder}`);
+    }
+    console.log(`Migrated SVG to lock for ${metadata.iconKey}`);
+}
+async function migrateSvgToFile(filePath, iconKey) {
+    if (!filePath || !iconKey)
+        return;
+    const pwd = await getPwd();
+    const outputPath = path.join(pwd, filePath);
+    const exists = await fs
+        .access(outputPath)
+        .then(() => true)
+        .catch(() => false);
+    if (exists) {
+        console.log(`File ${outputPath} already exists`);
+        return;
+    }
+    const lockFile = await getLockFile();
+    if (!lockFile)
+        throw new Error(`Lock file not found`);
+    const icon = lockFile.icons[iconKey];
+    if (!icon)
+        throw new Error(`Icon ${iconKey} not found in lock file`);
+    const folder = path.dirname(outputPath);
+    await fs.mkdir(folder, { recursive: true });
+    const content = await getIconContent(icon);
+    await fs.writeFile(outputPath, content);
+    icon.svg.content = `file://${filePath}`;
+    icon.svg.hash = crypto.createHash("sha256").update(content).digest("hex");
+    lockFile.icons[iconKey] = icon;
+    await setLockFile(lockFile);
+    console.log(`Migrated SVG to file for ${iconKey}`);
+}
+async function removeIcon(action) {
+    const lockFile = await getLockFile();
+    if (!lockFile)
+        throw new Error(`Lock file not found`);
+    const icon = lockFile.icons[action.iconKey];
+    if (!icon)
+        throw new Error(`Icon ${action.iconKey} not found in lock file`);
+    for (const [targetId, target] of Object.entries(icon.targets)) {
+        await removeExtraTarget({
+            type: "REMOVE_EXTRA_TARGET",
+            iconKey: action.iconKey,
+            targetId,
+            filePath: target.path,
+            status: "pending",
+            percentage: 0,
+        });
+    }
+    if (icon.svg.content.startsWith("file://")) {
+        const iconPath = icon.svg.content.replace("file://", "");
+        const pwd = await getPwd();
+        const filePath = path.join(pwd, iconPath);
+        const exists = await fs
+            .access(filePath)
+            .then(() => true)
+            .catch(() => false);
+        if (exists) {
+            await fs.unlink(filePath);
+            const folder = path.dirname(filePath);
+            const files = await fs.readdir(folder).catch(() => []);
+            if (files.length === 0) {
+                await fs.rmdir(folder).catch(() => { });
+            }
+        }
+    }
+    delete lockFile.icons[action.iconKey];
+    await setLockFile(lockFile);
+    console.log(`Removed icon ${action.iconKey}`);
+}
+async function regenerateAll(action, actionId, table) {
+    const lockFile = await getLockFile();
+    if (!lockFile)
+        throw new Error(`Lock file not found`);
+    const iconKeys = Object.keys(lockFile.icons);
+    const totalIcons = iconKeys.length;
+    if (totalIcons === 0) {
+        console.log("No icons to regenerate");
+        return;
+    }
+    table.update(actionId, {
+        ...action,
+        status: "processing",
+        percentage: 0,
+    });
+    for (let i = 0; i < iconKeys.length; i++) {
+        const iconKey = iconKeys[i];
+        try {
+            await regenerateIcon({
+                type: "REGENERATE_ICON",
+                iconKey,
+                status: "pending",
+                percentage: 0,
+            });
+            const percentage = Math.round(((i + 1) / totalIcons) * 100);
+            table.update(actionId, {
+                ...action,
+                status: "processing",
+                percentage,
+            });
+            console.log(`Regenerated icon ${iconKey} (${i + 1}/${totalIcons})`);
+        }
+        catch (error) {
+            console.error(`Failed to regenerate icon ${iconKey}:`, error);
+        }
+    }
+    console.log(`Regenerated all ${totalIcons} icons`);
+}
+async function regenerateIcon(action) {
+    const lockFile = await getLockFile();
+    if (!lockFile)
+        throw new Error(`Lock file not found`);
+    const icon = lockFile.icons[action.iconKey];
+    if (!icon)
+        throw new Error(`Icon ${action.iconKey} not found in lock file`);
+    const svgContent = await getIconContent(icon);
+    const iconName = icon.name;
+    const tags = icon.tags;
+    await removeIcon({
+        type: "REMOVE_ICON",
+        iconKey: action.iconKey,
+        status: "pending",
+        percentage: 0,
+    });
+    await createIcon({
+        type: "CREATE_ICON",
+        metadata: {
+            name: iconName,
+            tags,
+            content: svgContent,
+        },
+        status: "pending",
+        percentage: 0,
+    });
+    console.log(`Regenerated icon ${action.iconKey}`);
+}
+async function createIcon(action) {
+    if (!action.metadata ||
+        !("name" in action.metadata) ||
+        !("tags" in action.metadata) ||
+        !("content" in action.metadata)) {
+        throw new Error("CREATE_ICON action requires metadata with name, tags, and content");
+    }
+    const { name: iconName, tags, content } = action.metadata;
+    const iconKey = iconName.toLowerCase().replace(/ /g, "-");
+    const config = await getConfig();
+    if (!config)
+        throw new Error("Config not found");
+    const colorMap = action.metadata.colorMap;
+    const optimizedResult = optimize(content, {
+        ...config.svgo,
+        plugins: [
+            ...(config.svgo?.plugins ?? []),
+            "convertStyleToAttrs",
+            ...(colorMap
+                ? [
+                    mapColors({
+                        map: colorMap,
+                        replaceStyleElementText: true,
+                        replaceInlineStyle: true,
+                    }),
+                ]
+                : []),
+        ],
+    });
+    const optimizedContent = optimizedResult.data;
+    const { content: svgContent, hash: svgHash } = await setContent(config, iconKey, optimizedContent);
+    const lockFile = await getLockFile();
+    if (!lockFile)
+        throw new Error("Lock file not found");
+    let icon = lockFile.icons[iconKey];
+    const colorVariableKeys = Object.values(colorMap || {}).map((variable) => variable);
+    if (icon) {
+        icon.name = iconKey;
+        icon.tags = tags;
+        icon.svg.content = svgContent;
+        icon.svg.hash = svgHash;
+        icon.targets = {};
+        icon.colorVariableKeys = colorVariableKeys;
+    }
+    else {
+        icon = {
+            name: iconKey,
+            tags,
+            svg: {
+                content: svgContent,
+                hash: svgHash,
+            },
+            targets: {},
+            colorVariableKeys,
+        };
+    }
+    lockFile.icons[iconKey] = icon;
+    await setLockFile(lockFile);
+    for (const target of config.extraTargets) {
+        const filePath = target.outputPath.replace("{name}", iconKey);
+        createAction({
+            type: "ADD_EXTRA_TARGET",
+            targetId: target.targetId,
+            filePath,
+            iconKey,
+        });
+    }
+    console.log(`Created/updated icon ${iconKey}`);
+    return icon;
+}

package/dist/api/db.d.ts

@@ -0,0 +1,11 @@
+export declare function table<T>(tableName?: string): {
+    create: (value: T) => number;
+    get: (id: number) => T | undefined;
+    update: (id: number, value: T) => Map<number, any>;
+    delete: (id: number) => boolean;
+    getAll: () => (T & {
+        id: number;
+    })[];
+};
+export type Table<T> = ReturnType<typeof table<T>>;
+//# sourceMappingURL=db.d.ts.map

package/dist/api/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../api/db.ts"],"names":[],"mappings":"AAEA,wBAAgB,KAAK,CAAC,CAAC,EAAE,SAAS,GAAE,MAAkB;oBASlC,CAAC;cAMP,MAAM,KAAG,CAAC,GAAG,SAAS;iBACnB,MAAM,SAAS,CAAC;iBAChB,MAAM;kBACP,CAAC,CAAC,GAAG;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE;EAGrC;AAED,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/api/db.js

@@ -0,0 +1,20 @@
+const db = new Map();
+export function table(tableName = "default") {
+    let data = db.get(tableName);
+    if (!data) {
+        data = new Map();
+        db.set(tableName, data);
+    }
+    return {
+        create: (value) => {
+            const size = data.size;
+            const id = size + 1;
+            data.set(id, value);
+            return id;
+        },
+        get: (id) => data.get(id),
+        update: (id, value) => data.set(id, value),
+        delete: (id) => data.delete(id),
+        getAll: () => Array.from(data.values()).map((value, id) => ({ ...value, id })),
+    };
+}

package/dist/api/index.d.ts

@@ -0,0 +1,4 @@
+import { Router } from "express";
+declare const apiRoutes: Router;
+export default apiRoutes;
+//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,MAAM,SAAS,CAAC;AAevC,QAAA,MAAM,SAAS,EAAE,MAAiB,CAAC;AAgRnC,eAAe,SAAS,CAAC"}

package/dist/api/index.js

@@ -0,0 +1,201 @@
+import { Router, json } from "express";
+import { actionsTable, createAction, getConfig, getLockFile, getPwd, setConfig, toPascalFromSeparated, getIconContent, } from "./utils.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+const apiRoutes = Router();
+apiRoutes.use(json());
+apiRoutes.get("/pwd", async (req, res) => {
+    res.json({ pwd: await getPwd() });
+});
+apiRoutes.get("/config", async (req, res) => {
+    const config = await getConfig();
+    res.json(config);
+});
+apiRoutes.post("/config/changes", async (req, res) => {
+    const currentConfig = await getConfig();
+    const lockFile = await getLockFile();
+    const newConfig = req.body;
+    if (!currentConfig) {
+        return res.json({ changes: [] });
+    }
+    const addedExtraTargets = newConfig.extraTargets.filter((newTarget) => !currentConfig.extraTargets.some((currentTarget) => currentTarget.targetId === newTarget.targetId));
+    const removedExtraTargets = currentConfig.extraTargets.filter((currentTarget) => !newConfig.extraTargets.some((newTarget) => newTarget.targetId === currentTarget.targetId));
+    const changedExtraTargets = newConfig.extraTargets
+        .filter((newTarget) => currentConfig.extraTargets.some((currentTarget) => currentTarget.targetId === newTarget.targetId &&
+        currentTarget.outputPath !== newTarget.outputPath))
+        .filter((newTarget) => !addedExtraTargets.some((t) => t.targetId === newTarget.targetId) &&
+        !removedExtraTargets.some((t) => t.targetId === newTarget.targetId));
+    const changes = [];
+    const icons = lockFile?.icons || {};
+    for (const iconKey of Object.keys(icons)) {
+        const icon = icons[iconKey];
+        if (!icon)
+            continue;
+        if (newConfig.svg.folder !== currentConfig.svg.folder ||
+            newConfig.svg.inLock !== currentConfig.svg.inLock) {
+            const isFile = icon.svg.content.startsWith("file://");
+            if (isFile && newConfig.svg.inLock) {
+                changes.push({
+                    type: "MIGRATE_SVG_TO_LOCK",
+                    filePath: icon.svg.content.replace("file://", ""),
+                    metadata: {
+                        iconKey,
+                    },
+                });
+            }
+            if (!isFile && !newConfig.svg.inLock) {
+                if (!newConfig.svg.folder)
+                    continue;
+                const filePath = path.join(newConfig.svg.folder, iconKey + ".svg");
+                changes.push({
+                    type: "MIGRATE_SVG_TO_FILE",
+                    filePath,
+                    iconKey,
+                });
+            }
+        }
+        for (const addedTarget of addedExtraTargets) {
+            const filePath = addedTarget.outputPath.replace("{name}", iconKey);
+            changes.push({
+                type: "ADD_EXTRA_TARGET",
+                targetId: addedTarget.targetId,
+                filePath,
+                iconKey,
+            });
+        }
+        for (const removedTarget of removedExtraTargets) {
+            const filePath = removedTarget.outputPath.replace("{name}", iconKey);
+            changes.push({
+                type: "REMOVE_EXTRA_TARGET",
+                targetId: removedTarget.targetId,
+                filePath,
+                iconKey,
+            });
+        }
+        for (const changedTarget of changedExtraTargets) {
+            const filePath = changedTarget.outputPath.replace("{name}", iconKey);
+            const originalFilePath = currentConfig.extraTargets
+                .find((t) => t.targetId === changedTarget.targetId)
+                ?.outputPath.replace("{name}", iconKey);
+            changes.push({
+                type: "REMOVE_EXTRA_TARGET",
+                targetId: changedTarget.targetId,
+                filePath: originalFilePath,
+                iconKey,
+            });
+            changes.push({
+                type: "ADD_EXTRA_TARGET",
+                targetId: changedTarget.targetId,
+                filePath,
+                iconKey,
+            });
+        }
+    }
+    if (JSON.stringify(newConfig.svgo) !== JSON.stringify(currentConfig.svgo)) {
+        changes.push({
+            type: "REGENERATE_ALL",
+        });
+    }
+    res.json({ changes });
+});
+apiRoutes.post("/config", async (req, res) => {
+    const body = req.body;
+    await setConfig(body.config);
+    for (const change of body.changes) {
+        createAction(change);
+    }
+    res.json({ success: true });
+});
+apiRoutes.get("/actions", async (req, res) => {
+    const actions = actionsTable.getAll();
+    res.json({ actions });
+});
+apiRoutes.get("/icons", async (req, res) => {
+    const lockFile = await getLockFile();
+    if (!lockFile) {
+        return res.json({ icons: [] });
+    }
+    const icons = Object.entries(lockFile.icons).map(async ([iconKey, icon]) => {
+        const svgContent = await getIconContent(icon);
+        return {
+            iconKey,
+            icon,
+            svgContent,
+            pascalName: toPascalFromSeparated(iconKey),
+        };
+    });
+    const iconsWithContent = await Promise.all(icons);
+    res.json({ icons: iconsWithContent });
+});
+apiRoutes.post("/icons/create", async (req, res) => {
+    const body = req.body;
+    const icon = await createAction({
+        type: "CREATE_ICON",
+        metadata: {
+            name: body.name,
+            tags: body.tags,
+            content: body.content,
+            colorMap: body.colorMap,
+        },
+    });
+    if (!icon) {
+        return res.status(500).json({ error: "Icon not found after creation" });
+    }
+    res.json({ icon, pascalName: toPascalFromSeparated(body.name) });
+});
+apiRoutes.get("/icons/:iconKey", async (req, res) => {
+    const iconKey = req.params.iconKey;
+    if (!iconKey) {
+        return res.status(400).json({ error: "Icon key is required" });
+    }
+    const lockFile = await getLockFile();
+    if (!lockFile) {
+        return res.status(404).json({ error: "Lock file not found" });
+    }
+    const icon = lockFile.icons[iconKey];
+    if (!icon) {
+        return res.status(404).json({ error: "Icon not found" });
+    }
+    const svgContent = await getIconContent(icon);
+    res.json({
+        icon,
+        pascalName: toPascalFromSeparated(iconKey),
+        svgContent,
+    });
+});
+apiRoutes.delete("/icons/:iconKey", async (req, res) => {
+    const iconKey = req.params.iconKey;
+    if (!iconKey) {
+        return res.status(400).json({ error: "Icon key is required" });
+    }
+    const lockFile = await getLockFile();
+    if (!lockFile) {
+        return res.status(404).json({ error: "Lock file not found" });
+    }
+    const icon = lockFile.icons[iconKey];
+    if (!icon) {
+        return res.status(404).json({ error: "Icon not found" });
+    }
+    await createAction({
+        type: "REMOVE_ICON",
+        iconKey,
+    });
+    res.json({ success: true });
+});
+apiRoutes.get("/icons/content", async (req, res) => {
+    const filePath = req.query.path;
+    if (!filePath) {
+        return res.status(400).json({ error: "Path is required" });
+    }
+    const pwd = await getPwd();
+    const fullPath = path.join(pwd, filePath);
+    try {
+        const content = await fs.readFile(fullPath, "utf-8");
+        res.setHeader("Content-Type", "image/svg+xml");
+        res.send(content);
+    }
+    catch (error) {
+        res.status(404).json({ error: "File not found" });
+    }
+});
+export default apiRoutes;

package/dist/api/queue.d.ts

@@ -0,0 +1,6 @@
+declare const actionsQueue: import("fastq").queueAsPromised<{
+    actionId: number;
+    table: import("./db.js").Table<import("./types.js").ActionModel>;
+}, void | import("./types.js").LockFileIcon>;
+export { actionsQueue };
+//# sourceMappingURL=queue.d.ts.map

package/dist/api/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../api/queue.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,YAAY;;;yCAA0B,CAAC;AAE7C,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/api/queue.js

@@ -0,0 +1,4 @@
+import { promise as fastq } from "fastq";
+import { actionsWorker } from "./actions.js";
+const actionsQueue = fastq(actionsWorker, 1);
+export { actionsQueue };

package/dist/api/svgo-plugin-map-colors.d.ts

@@ -0,0 +1,11 @@
+export type ColorMap = Record<string, string>;
+export type MapColorsParams = {
+    map: ColorMap;
+    attributes?: string[];
+    replaceInlineStyle?: boolean;
+    replaceStyleElementText?: boolean;
+};
+export declare const mapColorsPluginBase: any;
+export declare function mapColors(params: MapColorsParams): any;
+export default mapColorsPluginBase;
+//# sourceMappingURL=svgo-plugin-map-colors.d.ts.map

package/dist/api/svgo-plugin-map-colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svgo-plugin-map-colors.d.ts","sourceRoot":"","sources":["../../api/svgo-plugin-map-colors.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,QAAQ,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,CAAC;AA8HF,eAAO,MAAM,mBAAmB,EA2G3B,GAAG,CAAC;AAET,wBAAgB,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,GAAG,CAStD;AAED,eAAe,mBAAmB,CAAC"}