"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = void 0;
var _postcss = _interopRequireDefault(require("postcss"));
function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    };
}
const postcssFontLoaderPlugn = ({ exports , fontFamilyHash , fallbackFonts =[] , adjustFontFallback , variable , weight , style  })=>{
    return {
        postcssPlugin: "postcss-font-loader",
        Once (root) {
            let fontFamily;
            const normalizeFamily = (family)=>{
                return family.replace(/['"]/g, "");
            };
            const formatFamily = (family)=>{
                // Turn the font family unguessable to make it localy scoped
                return `'__${family.replace(/ /g, "_")}_${fontFamilyHash}'`;
            };
            // Hash font-family name
            for (const node of root.nodes){
                if (node.type === "atrule" && node.name === "font-face") {
                    const familyNode = node.nodes.find((decl)=>decl.prop === "font-family");
                    if (!familyNode) {
                        continue;
                    }
                    const currentFamily = normalizeFamily(familyNode.value);
                    if (!fontFamily) {
                        fontFamily = currentFamily;
                    } else if (fontFamily !== currentFamily) {
                        throw new Error(`Font family mismatch, expected ${fontFamily} but got ${currentFamily}`);
                    }
                    familyNode.value = formatFamily(fontFamily);
                }
            }
            if (!fontFamily) {
                throw new Error("Font loaders must have exactly one font family");
            }
            // Add fallback font with override values
            let adjustFontFallbackFamily;
            if (adjustFontFallback) {
                adjustFontFallbackFamily = formatFamily(`${fontFamily} Fallback`);
                const fallbackFontFace = _postcss.default.atRule({
                    name: "font-face"
                });
                const { fallbackFont , ascentOverride , descentOverride , lineGapOverride , sizeAdjust ,  } = adjustFontFallback;
                fallbackFontFace.nodes = [
                    new _postcss.default.Declaration({
                        prop: "font-family",
                        value: adjustFontFallbackFamily
                    }),
                    new _postcss.default.Declaration({
                        prop: "src",
                        value: `local("${fallbackFont}")`
                    }),
                    ...ascentOverride ? [
                        new _postcss.default.Declaration({
                            prop: "ascent-override",
                            value: ascentOverride
                        }), 
                    ] : [],
                    ...descentOverride ? [
                        new _postcss.default.Declaration({
                            prop: "descent-override",
                            value: descentOverride
                        }), 
                    ] : [],
                    ...lineGapOverride ? [
                        new _postcss.default.Declaration({
                            prop: "line-gap-override",
                            value: lineGapOverride
                        }), 
                    ] : [],
                    ...sizeAdjust ? [
                        new _postcss.default.Declaration({
                            prop: "size-adjust",
                            value: sizeAdjust
                        }), 
                    ] : [], 
                ];
                root.nodes.push(fallbackFontFace);
            }
            const formattedFontFamilies = [
                formatFamily(fontFamily),
                ...fallbackFonts,
                ...adjustFontFallbackFamily ? [
                    adjustFontFallbackFamily
                ] : [], 
            ].join(", ");
            // Add class with family, weight and style
            const classRule = new _postcss.default.Rule({
                selector: ".className"
            });
            classRule.nodes = [
                new _postcss.default.Declaration({
                    prop: "font-family",
                    value: formattedFontFamilies
                }),
                ...weight ? [
                    new _postcss.default.Declaration({
                        prop: "font-weight",
                        value: weight
                    }), 
                ] : [],
                ...style ? [
                    new _postcss.default.Declaration({
                        prop: "font-style",
                        value: style
                    }), 
                ] : [], 
            ];
            root.nodes.push(classRule);
            // Add class that defines a variable with the font family
            if (variable) {
                const varialbeRule = new _postcss.default.Rule({
                    selector: ".variable"
                });
                varialbeRule.nodes = [
                    new _postcss.default.Declaration({
                        prop: variable,
                        value: formattedFontFamilies
                    }), 
                ];
                root.nodes.push(varialbeRule);
            }
            // Export @font-face values as is
            exports.push({
                name: "style",
                value: {
                    fontFamily: formattedFontFamilies,
                    fontWeight: weight && Number(weight),
                    fontStyle: style
                }
            });
        }
    };
};
postcssFontLoaderPlugn.postcss = true;
var _default = postcssFontLoaderPlugn;
exports.default = _default;

//# sourceMappingURL=postcss-font-loader.js.map