webfont 11.2.26 → 12.1.0

package/dist/src/index.d.ts

@@ -1,3 +1,5 @@
-import { webfont } from "./standalone";
-export { webfont } from "./standalone";
+import { webfont } from './standalone';
+export { diagnoseGlyphsData, diagnoseSvgContents } from './lib/svgDiagnostics/diagnoseSvgContents';
+export { webfont } from './standalone';
+export type { SvgDiagnosticCode, SvgGlyphDiagnostic, SvgToolsOptions } from './types/SvgToolsOptions';
 export default webfont;

package/dist/src/lib/applyOptimizeSvgToGlyphs.d.ts

@@ -0,0 +1,3 @@
+import { Config } from 'svgo';
+import { GlyphData } from '../types/GlyphData';
+export declare const applyOptimizeSvgToGlyphs: (glyphs: GlyphData[], svgoConfig?: Config) => GlyphData[];

package/dist/src/lib/evenoddFillRule.d.ts

@@ -0,0 +1,2 @@
+export declare const hasEvenoddFillRule: (svgContents: string) => boolean;
+export declare const evenoddFillRuleWarning: (srcPath: string) => string;

package/dist/src/lib/execCLI/index.d.ts

@@ -1,13 +1,12 @@
-/// <reference types="node" />
-import { ExecException } from "child_process";
-export declare type Output = {
+import { ExecException } from 'child_process';
+export type Output = {
     code?: number;
     error: ExecException | null;
     files: string[];
     stderr?: string;
     stdout?: string;
 };
-export declare type ExecCLI = (args?: string, destination?: string) => Promise<Output>;
+export type ExecCLI = (_args?: string, _destination?: string) => Promise<Output>;
 /**
  * @name execCLI
  * @description Execute webfont CLI commands using child_process.

package/dist/src/lib/inputSource.d.ts

@@ -0,0 +1,2 @@
+export { getInputExtension, getWebfontSourceBasename, isHttpUrl, resolveDecompressedFontBasenames, } from './inputSourceUtils';
+export declare const resolveInputSources: (patterns: readonly string[]) => Promise<string[]>;

package/dist/src/lib/inputSourceUtils.d.ts

@@ -0,0 +1,4 @@
+export declare const isHttpUrl: (value: string) => boolean;
+export declare const getInputExtension: (source: string) => string;
+export declare const getWebfontSourceBasename: (source: string) => string;
+export declare const resolveDecompressedFontBasenames: (sources: readonly string[]) => string[];

package/dist/src/lib/largeFontLigatures.d.ts

@@ -0,0 +1,4 @@
+/** Glyph count above which OpenType ligatures often hurt browser layout (Firefox / DirectWrite). */
+export declare const LARGE_FONT_LIGATURE_GLYPH_THRESHOLD = 2000;
+export declare const shouldWarnLargeFontLigatures: (glyphCount: number, ligaturesEnabled: boolean) => boolean;
+export declare const formatLargeFontLigatureWarning: (glyphCount: number) => string;

package/dist/src/lib/optimizeSvgGlyphs.d.ts

@@ -0,0 +1,4 @@
+import { Config } from 'svgo';
+/** Conservative SVGO preset: cleanup cruft without rewriting paths or removing viewBox. */
+export declare const defaultWebfontSvgoConfig: () => Config;
+export declare const optimizeSvgContents: (contents: string, srcPath: string, config?: Config) => string;

package/dist/src/lib/p-limit/index.d.ts

@@ -0,0 +1,2 @@
+import { default as pLimit } from 'p-limit';
+export default pLimit;

package/dist/src/lib/parseFormats.d.ts

@@ -0,0 +1,4 @@
+import { Format, Formats } from '../types/Format';
+export declare const assertValidFormat: (value: unknown) => Format;
+export declare const parseFormatsList: (values: readonly unknown[]) => Formats;
+export declare const assertFormatsOption: (formats: unknown) => Formats;

package/dist/src/lib/parseTemplateOption.d.ts

@@ -0,0 +1,2 @@
+export type TemplateOption = string | string[];
+export declare const normalizeTemplateOption: (template: unknown) => string[];

package/dist/src/lib/runtimeEnvironment.d.ts

@@ -0,0 +1,4 @@
+/** True in browser tabs and Web Workers (including Vite `process` polyfills). */
+export declare const isBrowserOrWorkerRuntime: () => boolean;
+/** True only in real Node.js — not in browser tabs or Web Workers. */
+export declare const isNodeRuntime: () => boolean;

package/dist/src/lib/sfnt/flavor.d.ts

@@ -0,0 +1,2 @@
+export type SfntFlavor = "otf" | "ttf";
+export declare const getSfntFlavor: (buffer: Buffer) => SfntFlavor;

package/dist/src/lib/svgDiagnostics/diagnoseSvgContents.d.ts

@@ -0,0 +1,12 @@
+import { SvgGlyphDiagnostic } from '../../types/SvgToolsOptions';
+export declare const hasStrokeOnlySvg: (svgContents: string) => boolean;
+export declare const hasUnsupportedSvgElements: (svgContents: string) => boolean;
+export declare const diagnoseSvgContents: (srcPath: string, svgContents: string) => SvgGlyphDiagnostic[];
+export declare const diagnoseGlyphsData: (glyphs: ReadonlyArray<{
+    contents: string;
+    srcPath: string;
+}>) => SvgGlyphDiagnostic[];
+export declare const shouldLogDiagnostic: (diagnostic: SvgGlyphDiagnostic, options: {
+    diagnose?: boolean;
+    verbose?: boolean;
+}) => boolean;

package/dist/src/lib/svgFontOutput/emptyGlyphPaths.d.ts

@@ -0,0 +1,3 @@
+import { GlyphData } from '../../types/GlyphData';
+export declare const findEmptySvgFontGlyphNames: (svgFont: string) => string[];
+export declare const assertNonEmptySvgFontGlyphs: (svgFont: string, glyphsData: ReadonlyArray<Pick<GlyphData, "metadata" | "srcPath">>) => void;

package/dist/src/lib/svgTools/applySvgDiagnostics.d.ts

@@ -0,0 +1,13 @@
+import { GlyphData } from '../../types/GlyphData';
+import { SvgGlyphDiagnostic } from '../../types/SvgToolsOptions';
+export type SvgToolsReporter = (message: string) => void;
+export type ApplySvgDiagnosticsResult = {
+    diagnostics: SvgGlyphDiagnostic[];
+    glyphs: GlyphData[];
+};
+export declare const applySvgDiagnosticsToGlyphs: (glyphsData: GlyphData[], svgToolsInput: {
+    diagnose?: boolean;
+} | undefined, runtime?: {
+    reporter?: SvgToolsReporter;
+    verbose?: boolean;
+}) => ApplySvgDiagnosticsResult;

package/dist/src/lib/svgTools/applySvgTools.d.ts

@@ -0,0 +1,14 @@
+import { GlyphData } from '../../types/GlyphData';
+import { SvgGlyphDiagnostic, SvgToolsOptions } from '../../types/SvgToolsOptions';
+import { SvgToolsReporter } from './applySvgDiagnostics';
+export type { SvgToolsReporter } from './applySvgDiagnostics';
+export type ApplySvgToolsResult = {
+    diagnostics: SvgGlyphDiagnostic[];
+    glyphs: GlyphData[];
+};
+export type ApplySvgToolsRuntime = {
+    reporter?: SvgToolsReporter;
+    /** When true, logs evenodd diagnostics even if svgTools.diagnose is off (backward compatible with --verbose). */
+    verbose?: boolean;
+};
+export declare const applySvgToolsToGlyphs: (glyphsData: GlyphData[], svgToolsInput: SvgToolsOptions | undefined, runtime?: ApplySvgToolsRuntime) => ApplySvgToolsResult;

package/dist/src/lib/svgTools/normalizeSvgToolsOptions.d.ts

@@ -0,0 +1,2 @@
+import { SvgToolsOptions } from '../../types/SvgToolsOptions';
+export declare const normalizeSvgToolsOptions: (svgTools?: SvgToolsOptions) => SvgToolsOptions | undefined;

package/dist/src/lib/svgicons2svgfont/index.d.ts

@@ -0,0 +1,14 @@
+import { SVGIcons2SVGFontStreamOptions, fileSorter, getMetadataService, SVGIcons2SVGFontStream } from 'svgicons2svgfont';
+import { WebfontOptions } from '../../types';
+export { fileSorter, getMetadataService, SVGIcons2SVGFontStream };
+type MetadataServiceOptions = {
+    prependUnicode: boolean;
+    startUnicode: number;
+};
+export declare const getMetadataServiceOptions: (options: WebfontOptions) => MetadataServiceOptions;
+/**
+ * Coerce `round` for svgicons2svgfont; accepts number or numeric string (CLI/config).
+ * Returns undefined for undefined/null/empty/non-numeric/non-finite inputs.
+ */
+export declare const normalizeRoundOption: (round: string | number | null | undefined) => number | undefined;
+export declare const getFontStreamOptions: (options: WebfontOptions) => Partial<SVGIcons2SVGFontStreamOptions>;

package/dist/src/lib/svgicons2svgfont/metadataFromSrcPath.d.ts

@@ -0,0 +1,11 @@
+import { MetadataProvider } from '../../types/MetadataProvider';
+type MetadataServiceOptions = {
+    prependUnicode: boolean;
+    startUnicode: number;
+};
+/**
+ * Browser-safe metadata lookup from a virtual `srcPath` (no `fs`, no file rename).
+ * Mirrors {@link https://github.com/nfroidure/svgicons2svgfont | svgicons2svgfont} filename rules.
+ */
+export declare const createMetadataFromSrcPathService: (options?: Partial<MetadataServiceOptions>) => MetadataProvider;
+export {};

package/dist/src/lib/templateUnicodeRange.d.ts

@@ -0,0 +1,4 @@
+import { GlyphMetadata } from '../types/GlyphMetadata';
+export declare const collectCodePointsFromGlyphs: (glyphs: readonly Pick<GlyphMetadata, "unicode">[]) => number[];
+export declare const computeUnicodeRangeFromGlyphs: (glyphs: readonly Pick<GlyphMetadata, "unicode">[]) => string | undefined;
+export declare const resolveTemplateUnicodeRange: (unicodeRange: boolean | string | undefined, glyphs: readonly Pick<GlyphMetadata, "unicode">[]) => string | undefined;

package/dist/src/lib/ttf2eot/index.d.ts

@@ -0,0 +1,2 @@
+declare const convertTtfToEot: (ttf: Buffer) => Buffer;
+export default convertTtfToEot;

package/dist/src/lib/ttfEncode.d.ts

@@ -0,0 +1,5 @@
+export declare const encodeTtfToEot: (buffer: Buffer) => Buffer;
+export declare const encodeTtfToWoff: (buffer: Buffer, options?: {
+    metadata?: string;
+}) => Buffer;
+export declare const encodeTtfToWoff2: (buffer: Buffer) => Promise<Buffer>;

package/dist/src/standalone/convertTtfInput.d.ts

@@ -0,0 +1,3 @@
+import { Result } from '../types/Result';
+import { WebfontOptions } from '../types/WebfontOptions';
+export declare const convertTtfInput: (fontFiles: readonly string[], options: WebfontOptions) => Promise<Result>;

package/dist/src/standalone/convertWebfontInput.d.ts

@@ -0,0 +1,3 @@
+import { Result } from '../types/Result';
+import { WebfontOptions } from '../types/WebfontOptions';
+export declare const convertWebfontInput: (fontFiles: readonly string[], options: WebfontOptions) => Promise<Result>;

package/dist/src/standalone/defaultOptions.d.ts

@@ -0,0 +1,3 @@
+import { WebfontOptions } from '../types/WebfontOptions';
+/** Shared defaults for Node (`files`) and in-memory (`glyphs`) entry points. */
+export declare const defaultWebfontOptions: () => Omit<WebfontOptions, "files">;

package/dist/src/standalone/fetchWebfontUrl.d.ts

@@ -0,0 +1 @@
+export declare const fetchWebfontFromUrl: (url: string) => Promise<Buffer>;

package/dist/src/standalone/generateSvgFont.d.ts

@@ -0,0 +1,2 @@
+import { GlyphData, WebfontOptions } from '../types';
+export declare const generateSvgFont: (glyphsData: GlyphData[], options: WebfontOptions) => Promise<string>;

package/dist/src/standalone/getGlyphsDataFromInputs.d.ts

@@ -0,0 +1,3 @@
+import { GlyphData, WebfontOptions } from '../types';
+import { GlyphInput } from '../types/GlyphInput';
+export declare const getGlyphsDataFromInputs: (inputs: readonly GlyphInput[], options: WebfontOptions) => Promise<GlyphData[]>;

package/dist/src/standalone/glyphsData.d.ts

@@ -1,4 +1,4 @@
-import type { GlyphData, WebfontOptions } from "../types";
-declare type GlyphsDataGetter = (files: Array<GlyphData["srcPath"]>, options: WebfontOptions) => unknown;
+import { GlyphData, WebfontOptions } from '../types';
+type GlyphsDataGetter = (_files: Array<GlyphData["srcPath"]>, _options: WebfontOptions) => Promise<GlyphData[]>;
 export declare const getGlyphsData: GlyphsDataGetter;
 export {};

package/dist/src/standalone/index.d.ts

@@ -1,5 +1,10 @@
-import type { InitialOptions } from "../types";
-import type { Result } from "../types/Result";
-declare type Webfont = (initialOptions?: InitialOptions) => Promise<Result>;
+import { cosmiconfig } from 'cosmiconfig';
+import { InitialOptions } from '../types';
+import { Result } from '../types/Result';
+type CosmiconfigLoaded = NonNullable<Awaited<ReturnType<ReturnType<typeof cosmiconfig>["search"]>>>;
+export declare const loadWebfontConfig: (options: {
+    configFile?: string;
+}) => Promise<CosmiconfigLoaded | Record<string, never>>;
+type Webfont = (_initialOptions?: InitialOptions) => Promise<Result>;
 export declare const webfont: Webfont;
 export default webfont;

package/dist/src/standalone/inputMode.d.ts

@@ -0,0 +1,9 @@
+import { Format } from '../types/Format';
+export type InputMode = "empty" | "mixed" | "svg" | "ttf" | "webfont";
+export declare const classifyInputFiles: (filePaths: readonly string[]) => InputMode;
+export declare const assertSvgPipelineFormats: (formats: readonly Format[]) => void;
+export declare const filterInputFilesByMode: (filePaths: readonly string[], mode: InputMode) => string[];
+export type ConversionFormat = "otf" | "ttf";
+export type TtfEncodeFormat = "eot" | "ttf" | "woff" | "woff2";
+export declare const resolveTtfConversionFormats: (formats: readonly Format[]) => TtfEncodeFormat[];
+export declare const resolveWebfontConversionFormats: (formats: readonly Format[]) => ConversionFormat[];

package/dist/src/standalone/options.d.ts

@@ -1,5 +1,5 @@
-import type { InitialOptions } from "../types/InitialOptions";
-import { WebfontOptions } from "../types/WebfontOptions";
-declare type OptionsGetter = (initialOptions?: InitialOptions) => WebfontOptions;
+import { InitialOptions } from '../types/InitialOptions';
+import { WebfontOptions } from '../types/WebfontOptions';
+type OptionsGetter = (_initialOptions?: InitialOptions) => WebfontOptions;
 export declare const getOptions: OptionsGetter;
 export {};

package/dist/src/standalone/optionsFromGlyphs.d.ts

@@ -0,0 +1,3 @@
+import { WebfontFromGlyphsOptions } from '../types/WebfontFromGlyphsOptions';
+import { WebfontOptions } from '../types/WebfontOptions';
+export declare const getOptionsFromGlyphs: (initialOptions: WebfontFromGlyphsOptions) => WebfontOptions;

package/dist/src/standalone/renderTemplates.d.ts

@@ -0,0 +1,10 @@
+import { Format } from '../types/Format';
+import { RenderedTemplate } from '../types/RenderedTemplate';
+import { Result } from '../types/Result';
+import { WebfontOptions } from '../types/WebfontOptions';
+type RenderTemplatesResult = {
+    templates: RenderedTemplate[];
+    usedBuildInTemplate: boolean;
+};
+export declare const renderTemplates: (options: WebfontOptions, result: Pick<Result, "glyphsData" | "hash"> & Partial<Result>, formats: readonly Format[]) => RenderTemplatesResult;
+export {};

package/dist/src/standalone/runSvgPipeline.d.ts

@@ -0,0 +1,3 @@
+import { GlyphData, WebfontOptions } from '../types';
+import { Result } from '../types/Result';
+export declare const runSvgPipeline: (glyphsData: GlyphData[], options: WebfontOptions) => Promise<Result>;

package/dist/src/standalone/templateFonts.d.ts

@@ -0,0 +1,3 @@
+import { Format } from '../types/Format';
+import { Result } from '../types/Result';
+export declare const getTemplateFontBase64: (format: Format, result: Result) => string;

package/dist/src/standalone/toTtf.d.ts

@@ -0,0 +1,4 @@
+import { default as svg2ttf } from 'svg2ttf';
+export type ToTtfOptions = Parameters<typeof svg2ttf>[1];
+declare const toTtf: (svgFontString: string, options?: ToTtfOptions) => Buffer;
+export default toTtf;

package/dist/src/standalone/validateWebfontOptions.d.ts

@@ -0,0 +1,6 @@
+import { WebfontOptions } from '../types/WebfontOptions';
+/**
+ * Runtime validation for merged webfont options (API, cosmiconfig, CLI).
+ * Rejects mis-typed or unknown format names before running a pipeline (#133).
+ */
+export declare const validateWebfontOptions: (options: WebfontOptions) => WebfontOptions;

package/dist/src/standalone/webfontFromGlyphs.d.ts

@@ -0,0 +1,3 @@
+import { Result } from '../types/Result';
+import { WebfontFromGlyphsOptions } from '../types/WebfontFromGlyphsOptions';
+export declare const webfontFromGlyphs: (initialOptions: WebfontFromGlyphsOptions) => Promise<Result>;

package/dist/src/types/DecompressedFont.d.ts

@@ -0,0 +1,5 @@
+export type DecompressedFont = {
+    source: string;
+    ttf?: Buffer;
+    otf?: Buffer;
+};

package/dist/src/types/Format.d.ts

@@ -1,9 +1,9 @@
-export declare type Format = "eot" | "woff" | "woff2" | "svg" | "ttf";
-export declare type Formats = Array<Format>;
-declare type FormatOption = {
+export type Format = "eot" | "otf" | "woff" | "woff2" | "svg" | "ttf";
+export type Formats = Array<Format>;
+type FormatOption = {
     copyright: null;
     ts: null;
     version: null;
 };
-export declare type FormatsOptions = Partial<Record<Format, FormatOption>>;
+export type FormatsOptions = Partial<Record<Format, FormatOption>>;
 export {};

package/dist/src/types/GlyphContentTransformFn.d.ts

@@ -0,0 +1,2 @@
+import { GlyphData } from './GlyphData';
+export type GlyphContentTransformFn = (_glyph: GlyphData) => string | Promise<string>;

package/dist/src/types/GlyphData.d.ts

@@ -1,5 +1,5 @@
-import { GlyphMetadata } from "./GlyphMetadata";
-export declare type GlyphData = {
+import { GlyphMetadata } from './GlyphMetadata';
+export type GlyphData = {
     contents: string;
     metadata?: GlyphMetadata;
     srcPath: string;

package/dist/src/types/GlyphInput.d.ts

@@ -0,0 +1,6 @@
+export type GlyphInput = {
+    /** SVG source text. */
+    contents: string;
+    /** Logical path or filename used for metadata (defaults to `icon.svg`). */
+    srcPath?: string;
+};

package/dist/src/types/GlyphMetadata.d.ts

@@ -1,4 +1,4 @@
-export declare type GlyphMetadata = {
+export type GlyphMetadata = {
     name: string;
     /**
      * @example

package/dist/src/types/GlyphTransformFn.d.ts

@@ -1,2 +1,2 @@
-import { GlyphMetadata } from "./GlyphMetadata";
-export declare type GlyphTransformFn = (obj: GlyphMetadata) => GlyphMetadata | Promise<GlyphMetadata>;
+import { GlyphMetadata } from './GlyphMetadata';
+export type GlyphTransformFn = (_obj: GlyphMetadata) => GlyphMetadata | Promise<GlyphMetadata>;

package/dist/src/types/InitialOptions.d.ts

@@ -1,7 +1,10 @@
-import { GlyphTransformFn } from "./GlyphTransformFn";
-import { OptionsBase } from "./OptionsBase";
-export declare type InitialOptions = OptionsBase & {
-    filePath?: string;
+import { GlyphContentTransformFn } from './GlyphContentTransformFn';
+import { GlyphTransformFn } from './GlyphTransformFn';
+import { MetadataProvider } from './MetadataProvider';
+import { OptionsBase } from './OptionsBase';
+export type InitialOptions = OptionsBase & {
     files: string | Array<string>;
+    glyphContentTransformFn?: GlyphContentTransformFn;
     glyphTransformFn?: GlyphTransformFn;
+    metadataProvider?: MetadataProvider;
 };

package/dist/src/types/MetadataProvider.d.ts

@@ -0,0 +1,5 @@
+export type FileMetadata = {
+    name: string;
+    unicode?: string | string[];
+};
+export type MetadataProvider = (srcPath: string, callback: (error: Error | null, metadata?: FileMetadata) => void) => void;

package/dist/src/types/OptionsBase.d.ts

@@ -1,11 +1,13 @@
-import { Formats } from "./Format";
-export declare type OptionsBase = {
+import { TemplateOption } from '../lib/parseTemplateOption';
+import { Formats } from './Format';
+import { SvgToolsOptions } from './SvgToolsOptions';
+export type OptionsBase = {
     configFile?: string;
     dest?: string;
     destCreate?: boolean;
     fontName?: string | unknown;
     formats?: Formats;
-    template?: "css" | string;
+    template?: TemplateOption;
     templateClassName?: string | unknown;
     templateFontPath?: string;
     templateFontName?: string | unknown;
@@ -26,5 +28,12 @@ export declare type OptionsBase = {
     prependUnicode?: boolean | unknown;
     metadata?: unknown;
     sort?: boolean;
+    ligatures?: boolean;
     addHashInFontUrl?: boolean | unknown;
+    unicodeRange?: boolean | string | unknown;
+    optimizeSvg?: boolean | unknown;
+    svgoConfig?: unknown;
+    templateFontLigatures?: boolean | unknown;
+    /** Alpha. SVG diagnostics and optional pre-conversion fixes. */
+    svgTools?: SvgToolsOptions;
 };

package/dist/src/types/RenderedTemplate.d.ts

@@ -0,0 +1,7 @@
+export type RenderedTemplate = {
+    /** Original template option (built-in name or custom path). */
+    template: string;
+    content: string;
+    /** Built-in template id when applicable (css, html, scss, …). */
+    builtIn?: string;
+};

package/dist/src/types/Result.d.ts

@@ -1,15 +1,26 @@
-/// <reference types="node" />
-import { GlyphData } from "./GlyphData";
-import { OptionsBase } from "./OptionsBase";
-export declare type Result = {
-    config?: OptionsBase;
+import { DecompressedFont } from './DecompressedFont';
+import { GlyphData } from './GlyphData';
+import { RenderedTemplate } from './RenderedTemplate';
+import { ResultConfig } from './ResultConfig';
+import { SvgGlyphDiagnostic } from './SvgToolsOptions';
+import { TranscodedFont } from './TranscodedFont';
+export type { DecompressedFont } from './DecompressedFont';
+export type { TranscodedFont } from './TranscodedFont';
+export type Result = {
+    config?: ResultConfig;
+    decompressedFonts?: DecompressedFont[];
+    transcodedFonts?: TranscodedFont[];
     eot?: Buffer;
     glyphsData?: Array<GlyphData>;
     hash?: string;
+    otf?: Buffer;
     svg?: string | Buffer;
     template?: string;
+    templates?: RenderedTemplate[];
     ttf?: Buffer;
     usedBuildInTemplate?: boolean;
     woff?: Buffer;
     woff2?: Buffer;
+    /** Alpha. Populated when `svgTools.diagnose` is enabled. */
+    svgDiagnostics?: SvgGlyphDiagnostic[];
 };

package/dist/src/types/ResultConfig.d.ts

@@ -0,0 +1,4 @@
+import { WebfontOptions } from './WebfontOptions';
+export type ResultConfig = WebfontOptions & {
+    filePath?: string;
+};

package/dist/src/types/SvgToolsOptions.d.ts

@@ -0,0 +1,13 @@
+export type SvgDiagnosticCode = "evenodd-fill-rule" | "stroke-only" | "unsupported-element";
+export type SvgGlyphDiagnostic = {
+    code: SvgDiagnosticCode;
+    message: string;
+    srcPath: string;
+};
+/** Alpha. SVG diagnostics for the icon-font pipeline (see ADR 0011 — no bundled stroke-to-fill fixes). */
+export type SvgToolsOptions = {
+    /** Scan source SVGs for known icon-font incompatibilities and report warnings. */
+    diagnose?: boolean;
+    /** Optional sink for diagnostic log lines (for example a web worker or test spy). */
+    onMessage?: (message: string) => void;
+};

package/dist/src/types/TranscodedFont.d.ts

@@ -0,0 +1,7 @@
+export type TranscodedFont = {
+    source: string;
+    eot?: Buffer;
+    ttf?: Buffer;
+    woff?: Buffer;
+    woff2?: Buffer;
+};

package/dist/src/types/WebfontFromGlyphsOptions.d.ts

@@ -0,0 +1,11 @@
+import { GlyphContentTransformFn } from './GlyphContentTransformFn';
+import { GlyphInput } from './GlyphInput';
+import { GlyphTransformFn } from './GlyphTransformFn';
+import { MetadataProvider } from './MetadataProvider';
+import { OptionsBase } from './OptionsBase';
+export type WebfontFromGlyphsOptions = OptionsBase & {
+    glyphs: GlyphInput[];
+    glyphContentTransformFn?: GlyphContentTransformFn;
+    glyphTransformFn?: GlyphTransformFn;
+    metadataProvider?: MetadataProvider;
+};

package/dist/src/types/WebfontOptions.d.ts

@@ -1,7 +1,43 @@
-import type { FormatsOptions } from "./Format";
-import type { InitialOptions } from "./InitialOptions";
+import { Config as SvgoConfig } from 'svgo';
+import { TemplateOption } from '../lib/parseTemplateOption';
+import { Formats, FormatsOptions } from './Format';
+import { GlyphContentTransformFn } from './GlyphContentTransformFn';
+import { GlyphTransformFn } from './GlyphTransformFn';
+import { InitialOptions } from './InitialOptions';
+import { MetadataProvider } from './MetadataProvider';
+import { SvgToolsOptions } from './SvgToolsOptions';
 export interface WebfontOptions extends InitialOptions {
+    centerHorizontally: boolean;
+    descent: number;
+    fixedWidth: boolean;
+    fontHeight: unknown;
+    fontId: unknown;
+    fontName: string;
+    fontStyle: string;
+    fontWeight: string;
+    formats: Formats;
     formatsOptions: FormatsOptions;
+    glyphTransformFn?: GlyphTransformFn;
+    glyphContentTransformFn?: GlyphContentTransformFn;
+    ligatures: boolean;
     maxConcurrency: number;
-    metadataProvider: null;
+    metadata: unknown;
+    metadataProvider?: MetadataProvider;
+    normalize: boolean;
+    prependUnicode: boolean;
+    round: string | number;
+    sort: boolean;
+    startUnicode: number;
+    template?: TemplateOption;
+    templateCacheString?: unknown;
+    templateClassName?: unknown;
+    templateFontName?: unknown;
+    templateFontPath: string;
+    verbose: boolean;
+    addHashInFontUrl?: boolean;
+    unicodeRange?: boolean | string;
+    optimizeSvg?: boolean;
+    svgoConfig?: SvgoConfig;
+    templateFontLigatures?: boolean;
+    svgTools?: SvgToolsOptions;
 }

package/dist/src/types/index.d.ts

@@ -1,6 +1,8 @@
-export type { Format } from "../types/Format";
-export type { GlyphMetadata } from "./GlyphMetadata";
-export type { GlyphTransformFn } from "./GlyphTransformFn";
-export type { GlyphData } from "./GlyphData";
-export type { InitialOptions } from "./InitialOptions";
-export type { WebfontOptions } from "./WebfontOptions";
+export type { Format, FormatsOptions } from '../types/Format';
+export type { GlyphContentTransformFn } from './GlyphContentTransformFn';
+export type { GlyphData } from './GlyphData';
+export type { GlyphMetadata } from './GlyphMetadata';
+export type { GlyphTransformFn } from './GlyphTransformFn';
+export type { InitialOptions } from './InitialOptions';
+export type { MetadataProvider } from './MetadataProvider';
+export type { WebfontOptions } from './WebfontOptions';