@overpunch/vf-clamp 2.1.4

package/dist/index.d.ts

@@ -0,0 +1,160 @@
+/** One axis defined in the font's fvar table */
+export declare interface AxisDefinition {
+    /** Four-character axis tag, e.g. "wght", "wdth" */
+    tag: string;
+    /** Human-readable axis name from the font's name table */
+    name: string;
+    /** Minimum value on the axis */
+    minimum: number;
+    /** Default value (used when axis is not explicitly set) */
+    default: number;
+    /** Maximum value on the axis */
+    maximum: number;
+}
+
+/** Restrict an axis to a sub-range — the axis remains variable but clamped to [min, max] */
+export declare interface AxisRange {
+    /** Minimum value on the axis */
+    min: number;
+    /** Maximum value on the axis */
+    max: number;
+}
+
+/**
+ * What to do with one axis when clamping a variable font:
+ * - number: pin to that value (axis locked and removed from output design space)
+ * - AxisRange: restrict to [min, max] (axis stays variable within that range)
+ * - null: omit this axis from the instancer call — axis keeps its full original range
+ *
+ * Axes not listed in the config also keep their full original range.
+ * Note: JS→Python bridge limitations prevent true axis dropping (fonttools' Python `None` semantic).
+ */
+export declare type AxisValue = PinnedAxis | AxisRange | null;
+
+/**
+ * Produce one restricted variable font per output config from a source variable font.
+ * Outputs are processed sequentially (Pyodide is single-threaded).
+ *
+ * Each output can specify:
+ * - instances: named instances to include — hull (min/max per axis) computed automatically
+ * - axes: explicit axis constraints — override or extend the instance hull
+ *
+ * @param input - Source variable font binary (TTF, OTF, WOFF, or WOFF2)
+ * @param options - Output configs and optional format
+ * @returns One ClampResult per output, in the same order as options.outputs
+ */
+export declare function clampFont(input: ArrayBuffer | Uint8Array | Buffer, options: ClampOptions): Promise<ClampResult[]>;
+
+/** Options passed to clampFont() */
+export declare interface ClampOptions {
+    /** One entry per restricted variant to produce */
+    outputs: OutputConfig[];
+    /**
+     * Output format — defaults to 'ttf'.
+     * 'woff' and 'woff2' transcode the result to a web-compressed flavour.
+     * 'otf' is a passthrough — the instancer preserves the input outline format.
+     */
+    format?: OutputFormat;
+    /**
+     * Remap the wght axis so its minimum becomes 100, making CSS font-weight values
+     * (100–900) work as expected. Instance and STAT axis value coordinates are
+     * remapped proportionally; the avar is unchanged because the remapping preserves
+     * normalised values. Defaults to false — the axis keeps its original fvar range.
+     *
+     * Use this when the source font's design space starts above wght 100 (e.g. 250)
+     * and you need font-weight: 100 to reach the lightest weight.
+     */
+    normalizeWeightAxis?: boolean;
+}
+
+/** One output from clampFont() — a restricted variable font for a single output config */
+export declare interface ClampResult {
+    /** Matches OutputConfig.name (or the auto-derived instance range if name was omitted) */
+    name: string;
+    /** Restricted font binary — write to disk or upload; format matches options.format */
+    buffer: Uint8Array;
+    /** Format of the buffer — matches options.format, defaults to 'ttf' */
+    format: OutputFormat;
+}
+
+/**
+ * Produce a compact display name from the first and last selected instance names.
+ * Strips shared leading prefix and trailing suffix tokens, joins differing parts with a dash.
+ *
+ * Examples:
+ *   compactName('Inter Light', 'Inter Bold')         → 'Inter Light-Bold'
+ *   compactName('Condensed Thin', 'Condensed Black') → 'Condensed Thin-Black'
+ *   compactName('Regular', 'Regular')                → 'Regular'
+ *
+ * Canonical implementation — also duplicated in the Python plugins and VS Code webview
+ * (both sandboxed contexts that cannot import this package at runtime).
+ */
+export declare function compactName(first: string, last: string): string;
+
+/** Convert a font buffer to WOFF (zlib-compressed). */
+export declare function convertToWoff(input: Uint8Array | Buffer): Promise<Uint8Array>;
+
+/** Convert a font buffer to WOFF2 (Brotli-compressed). */
+export declare function convertToWoff2(input: Uint8Array | Buffer): Promise<Uint8Array>;
+
+/** One named instance from the font's fvar table */
+export declare interface FontInstance {
+    /** Instance name from the font's name table, e.g. "Regular", "Bold Condensed" */
+    name: string;
+    /** Axis coordinates for this instance, e.g. { wght: 400, wdth: 100 } */
+    coordinates: Record<string, number>;
+}
+
+/** Result of getInstances() — describes the full design space of a variable font */
+export declare interface FontInstancesResult {
+    /** All variable axes defined in the font */
+    axes: AxisDefinition[];
+    /** All named instances defined in the font */
+    instances: FontInstance[];
+}
+
+/**
+ * Extract axis definitions and named instances from a variable font's fvar table.
+ * Returns the full design space: which axes exist and what named positions are defined.
+ * Accepts TTF, OTF, WOFF, or WOFF2 input — fonttools handles all four formats.
+ *
+ * @param input - Source variable font binary (TTF, OTF, WOFF, or WOFF2)
+ * @returns Axis definitions and named instances, or empty arrays for a static font
+ */
+export declare function getInstances(input: ArrayBuffer | Uint8Array | Buffer): Promise<FontInstancesResult>;
+
+/**
+ * One output variant to produce from the source variable font.
+ * Specify instances, axes, or both — instances set the hull, axes override individual tags.
+ */
+export declare interface OutputConfig {
+    /** Name for this output — used in ClampResult.name. Defaults to instance range when omitted. */
+    name?: string;
+    /**
+     * Named instances to include. The axis hull (min/max per axis) is computed automatically
+     * across all listed instances — producing one variable font that spans exactly that range.
+     * Instance names must match the font's fvar name table exactly.
+     */
+    instances?: string[];
+    /**
+     * Explicit axis constraints, applied after any instance hull.
+     * Axes listed here override the hull computed from instances for that tag.
+     * Axis tags not listed keep their full original range.
+     */
+    axes?: Record<string, AxisValue>;
+}
+
+/**
+ * Output format for clampFont() — defaults to 'ttf'.
+ * 'woff' and 'woff2' transcode to web-compressed flavours.
+ * 'otf' is a passthrough (no outline conversion); the instancer preserves the input flavour.
+ */
+export declare type OutputFormat = 'ttf' | 'otf' | 'woff' | 'woff2';
+
+/** Pin an axis at a single value — the axis is locked and removed from the output font's design space */
+export declare type PinnedAxis = number;
+
+/** @deprecated Use OutputConfig instead */
+export declare type SubfamilyConfig = OutputConfig;
+
+export { }

package/dist/index.js

@@ -0,0 +1,553 @@
+import { createRequire as D } from "node:module";
+const I = D(import.meta.url), { preparePyodide: l, PyodideFile: u } = I("@web-alchemy/fonttools/src/pyodide.js");
+let g = null;
+async function P() {
+  return g || (g = l().then(
+    (t) => t.runPythonAsync(`
+from fontTools.ttLib import TTFont
+
+def vf_convert_flavor(file_options):
+    font = TTFont(file_options['input-file'])
+    font.flavor = file_options['flavor']
+    font.save(file_options['output-file'])
+
+vf_convert_flavor
+`)
+  )), g;
+}
+async function V(t, o) {
+  const a = await l(), e = new u({ pyodide: a }), n = new u({ pyodide: a });
+  try {
+    await e.upload(t);
+    const i = /* @__PURE__ */ new Map([
+      ["input-file", e.filename],
+      ["output-file", n.filename],
+      ["flavor", o]
+    ]);
+    return (await P())(i), n.download();
+  } finally {
+    try {
+      e.delete();
+    } catch {
+    }
+    try {
+      n.delete();
+    } catch {
+    }
+  }
+}
+async function R(t) {
+  return V(t, "woff");
+}
+async function N(t) {
+  return V(t, "woff2");
+}
+let h = null;
+async function O() {
+  return h || (h = l().then(
+    (t) => t.runPythonAsync(`
+import json
+from fontTools.ttLib import TTFont
+
+def get_instances_fn(input_file):
+    font = TTFont(input_file)
+
+    if 'fvar' not in font:
+        return json.dumps({'axes': [], 'instances': []})
+
+    fvar = font['fvar']
+    name_table = font['name']
+
+    axes = [
+        {
+            'tag': ax.axisTag,
+            'name': name_table.getDebugName(ax.axisNameID) or ax.axisTag,
+            'minimum': ax.minValue,
+            'default': ax.defaultValue,
+            'maximum': ax.maxValue,
+        }
+        for ax in fvar.axes
+    ]
+
+    instances = [
+        {
+            'name': name_table.getDebugName(inst.subfamilyNameID) or f'Instance {i}',
+            'coordinates': dict(inst.coordinates),
+        }
+        for i, inst in enumerate(fvar.instances)
+    ]
+
+    return json.dumps({'axes': axes, 'instances': instances})
+
+get_instances_fn
+`)
+  )), h;
+}
+async function j(t) {
+  const o = await l(), a = t instanceof ArrayBuffer ? new Uint8Array(t) : t, e = new u({ pyodide: o });
+  try {
+    await e.upload(a);
+    const i = (await O())(e.filename);
+    return JSON.parse(i);
+  } finally {
+    try {
+      e.delete();
+    } catch {
+    }
+  }
+}
+let w = null, v = null, y = null, A = null, T = null;
+async function L() {
+  return w || (w = l().then(
+    (t) => t.runPythonAsync(`
+from fontTools import ttLib
+
+def patch_font_names_fn(file_options):
+    font = ttLib.TTFont(file_options['input-file'])
+    name_table = font['name']
+    family_name  = file_options['family-name']
+    ps_name      = file_options['postscript-name']
+
+    existing_ids = {r.nameID for r in name_table.names}
+
+    # nameID 1 = Family, 4 = Full name, 6 = PostScript name
+    # nameID 2 = Subfamily — reset to 'Regular' so the restricted file does not
+    #            collide with the source font's Subfamily in OS font caches.
+    # nameID 3 = Unique ID — regenerate so it is distinct from the source font.
+    # nameID 16 = Preferred family (update only if present)
+    # nameID 25 = Variations PS Name Prefix (update only if present)
+    #
+    # head.fontRevision is a Fixed value (e.g. 1.000). Fall back to '1.000' if
+    # the head table is unreadable.
+    try:
+        version = '%.3f' % font['head'].fontRevision
+    except Exception:
+        version = '1.000'
+    unique_id = '%s;%s;%s' % (version, ps_name, family_name)
+
+    updates = {
+        1: family_name,
+        2: 'Regular',
+        3: unique_id,
+        4: family_name,
+        6: ps_name,
+    }
+    if 16 in existing_ids:
+        updates[16] = family_name
+    if 25 in existing_ids:
+        updates[25] = ps_name
+
+    for record in name_table.names:
+        if record.nameID not in updates:
+            continue
+        value = updates[record.nameID]
+        if record.platformID == 3:
+            record.string = value.encode('utf-16-be')
+        elif record.platformID == 1:
+            try:
+                record.string = value.encode('mac_roman')
+            except Exception:
+                record.string = value.encode('ascii', errors='replace')
+
+    font.save(file_options['output-file'])
+
+patch_font_names_fn
+`)
+  )), w;
+}
+async function M() {
+  return v || (v = l().then(
+    (t) => t.runPythonAsync(`
+from fontTools.ttLib import TTFont
+from fontTools.varLib import instancer
+import json
+
+def vf_clamp_instantiate(file_options, axes_json):
+    font = TTFont(file_options['input-file'])
+    axes_spec = json.loads(axes_json)
+
+    limits = {}
+    axes_by_tag = {ax.axisTag: ax for ax in font['fvar'].axes}
+
+    for tag, spec in axes_spec.items():
+        if spec is None:
+            continue
+        ax = axes_by_tag.get(tag)
+        if isinstance(spec, list):
+            mn = float(spec[0])
+            mx = float(spec[1])
+            default = ax.defaultValue if ax else (mn + mx) / 2
+            default = max(mn, min(mx, default))
+            limits[tag] = instancer.AxisTriple(mn, default, mx)
+        else:
+            limits[tag] = float(spec)
+
+    partial = instancer.instantiateVariableFont(font, limits)
+    partial.save(file_options['output-file'])
+
+vf_clamp_instantiate
+`)
+  )), v;
+}
+async function U() {
+  return y || (y = l().then(
+    (t) => t.runPythonAsync(`
+from fontTools.ttLib import TTFont
+
+def vf_clamp_normalize_wght(file_options, new_min_str):
+    new_min = float(new_min_str)
+    font = TTFont(file_options['input-file'])
+
+    if 'fvar' not in font:
+        font.save(file_options['output-file'])
+        return
+
+    wght_axis = next((ax for ax in font['fvar'].axes if ax.axisTag == 'wght'), None)
+
+    # Only normalize when the font's minimum is above the target (e.g. 251 > 100)
+    if wght_axis is None or wght_axis.minValue <= new_min:
+        font.save(file_options['output-file'])
+        return
+
+    old_min = wght_axis.minValue
+    default = wght_axis.defaultValue
+    scale = (default - new_min) / (default - old_min)
+
+    def remap(v):
+        return (default + (v - default) * scale) if v < default else v
+
+    # Update fvar axis minimum
+    wght_axis.minValue = new_min
+
+    # Update named instance wght coordinates
+    for inst in font['fvar'].instances:
+        if 'wght' in inst.coordinates:
+            inst.coordinates['wght'] = remap(inst.coordinates['wght'])
+
+    # Update STAT axis values that reference wght
+    if 'STAT' in font and font['STAT'].table.AxisValueArray:
+        stat = font['STAT'].table
+        wght_idx = None
+        if hasattr(stat, 'DesignAxisRecord') and stat.DesignAxisRecord:
+            for i, ax in enumerate(stat.DesignAxisRecord.Axis):
+                if ax.AxisTag == 'wght':
+                    wght_idx = i
+                    break
+        if wght_idx is not None:
+            for av in stat.AxisValueArray.AxisValue:
+                fmt = av.Format
+                if fmt in (1, 3) and av.AxisIndex == wght_idx:
+                    av.Value = remap(av.Value)
+                    if fmt == 3:
+                        av.LinkedValue = remap(av.LinkedValue)
+                elif fmt == 2 and av.AxisIndex == wght_idx:
+                    av.NominalValue = remap(av.NominalValue)
+                    av.RangeMinValue = remap(av.RangeMinValue)
+                    av.RangeMaxValue = remap(av.RangeMaxValue)
+
+    font.save(file_options['output-file'])
+
+vf_clamp_normalize_wght
+`)
+  )), y;
+}
+async function k() {
+  return A || (A = l().then(
+    (t) => t.runPythonAsync(`
+from fontTools.ttLib import TTFont
+
+def vf_clamp_prune_stat(file_options):
+    font = TTFont(file_options['input-file'])
+
+    if 'STAT' not in font or 'fvar' not in font:
+        font.save(file_options['output-file'])
+        return
+
+    stat = font['STAT'].table
+    if not getattr(stat, 'DesignAxisRecord', None) or not stat.DesignAxisRecord.Axis:
+        font.save(file_options['output-file'])
+        return
+
+    fvar_tags = {ax.axisTag for ax in font['fvar'].axes}
+    stat_axes = list(stat.DesignAxisRecord.Axis)
+
+    # Map old STAT AxisIndex -> new index after pruning STAT axes that vanish from fvar.
+    surviving_indices = [i for i, ax in enumerate(stat_axes) if ax.AxisTag in fvar_tags]
+    if len(surviving_indices) == len(stat_axes):
+        # No axes removed — nothing to prune.
+        font.save(file_options['output-file'])
+        return
+    old_to_new = {old: new for new, old in enumerate(surviving_indices)}
+
+    # Rewrite the DesignAxisRecord.Axis list to surviving axes only.
+    stat.DesignAxisRecord.Axis = [stat_axes[i] for i in surviving_indices]
+    if hasattr(stat, 'DesignAxisCount'):
+        stat.DesignAxisCount = len(stat.DesignAxisRecord.Axis)
+
+    # Prune AxisValueArray entries that reference removed axes.
+    if stat.AxisValueArray and stat.AxisValueArray.AxisValue:
+        kept = []
+        for av in stat.AxisValueArray.AxisValue:
+            fmt = av.Format
+            if fmt in (1, 2, 3):
+                if av.AxisIndex not in old_to_new:
+                    continue  # references a removed axis
+                av.AxisIndex = old_to_new[av.AxisIndex]
+                kept.append(av)
+            elif fmt == 4:
+                inner = list(getattr(av, 'AxisValueRecord', []) or [])
+                if any(rec.AxisIndex not in old_to_new for rec in inner):
+                    continue  # whole record dies if any inner ref is dead
+                for rec in inner:
+                    rec.AxisIndex = old_to_new[rec.AxisIndex]
+                kept.append(av)
+            else:
+                # Unknown format — keep as-is to be safe.
+                kept.append(av)
+        stat.AxisValueArray.AxisValue = kept
+        if hasattr(stat, 'AxisValueCount'):
+            stat.AxisValueCount = len(kept)
+
+    font.save(file_options['output-file'])
+
+vf_clamp_prune_stat
+`)
+  )), A;
+}
+async function $() {
+  return T || (T = l().then(
+    (t) => t.runPythonAsync(`
+from fontTools.ttLib import TTFont
+
+def vf_clamp_update_os2(file_options):
+    font = TTFont(file_options['input-file'])
+
+    if 'fvar' not in font:
+        font.save(file_options['output-file'])
+        return
+
+    wght_axis = next((ax for ax in font['fvar'].axes if ax.axisTag == 'wght'), None)
+    if wght_axis is None:
+        font.save(file_options['output-file'])
+        return
+
+    new_default = wght_axis.defaultValue
+    # OS/2.usWeightClass valid range is 1..1000.
+    weight_class = int(round(max(1, min(1000, new_default))))
+
+    if 'OS/2' in font:
+        os2 = font['OS/2']
+        os2.usWeightClass = weight_class
+        # fsSelection bits: 0x20 = BOLD, 0x40 = REGULAR.
+        # Mirror the convention: REGULAR when usWeightClass < 600, BOLD when >= 700.
+        fs = os2.fsSelection
+        fs &= ~(0x20 | 0x40)
+        if weight_class >= 700:
+            fs |= 0x20  # BOLD
+        elif weight_class < 600:
+            fs |= 0x40  # REGULAR
+        os2.fsSelection = fs
+
+    if 'head' in font:
+        head = font['head']
+        # macStyle bit 0 = bold.
+        ms = head.macStyle
+        if weight_class >= 700:
+            ms |= 0x01
+        else:
+            ms &= ~0x01
+        head.macStyle = ms
+
+    font.save(file_options['output-file'])
+
+vf_clamp_update_os2
+`)
+  )), T;
+}
+function C(t) {
+  return t.replace(/[^A-Za-z0-9 -]/g, "").trim().split(/\s+/).join("-").replace(/^-+|-+$/g, "").slice(0, 63);
+}
+async function z(t, o) {
+  if (!o) return t;
+  const a = await l(), e = new u({ pyodide: a }), n = new u({ pyodide: a });
+  try {
+    const i = C(o);
+    await e.upload(t);
+    const r = /* @__PURE__ */ new Map([
+      ["input-file", e.filename],
+      ["output-file", n.filename],
+      ["family-name", o],
+      ["postscript-name", i]
+    ]);
+    return (await L())(r), n.download();
+  } catch (i) {
+    return console.warn(`vf-clamp: name table patching failed for "${o}" — returning unpatched buffer`, i), t;
+  } finally {
+    try {
+      e.delete();
+    } catch {
+    }
+    try {
+      n.delete();
+    } catch {
+    }
+  }
+}
+function B(t) {
+  return typeof t == "number" ? t : t === null ? null : [t.min, t.max];
+}
+async function E(t, o) {
+  const a = await l(), e = new u({ pyodide: a }), n = new u({ pyodide: a });
+  try {
+    await e.upload(t);
+    const i = /* @__PURE__ */ new Map([
+      ["input-file", e.filename],
+      ["output-file", n.filename]
+    ]);
+    return (await M())(i, JSON.stringify(o)), n.download();
+  } finally {
+    try {
+      e.delete();
+    } catch {
+    }
+    try {
+      n.delete();
+    } catch {
+    }
+  }
+}
+async function W(t) {
+  const o = await l(), a = new u({ pyodide: o }), e = new u({ pyodide: o });
+  try {
+    await a.upload(t);
+    const n = /* @__PURE__ */ new Map([
+      ["input-file", a.filename],
+      ["output-file", e.filename]
+    ]);
+    return (await k())(n), e.download();
+  } catch (n) {
+    return console.warn("vf-clamp: STAT prune failed — returning unpruned buffer", n), t;
+  } finally {
+    try {
+      a.delete();
+    } catch {
+    }
+    try {
+      e.delete();
+    } catch {
+    }
+  }
+}
+async function q(t) {
+  const o = await l(), a = new u({ pyodide: o }), e = new u({ pyodide: o });
+  try {
+    await a.upload(t);
+    const n = /* @__PURE__ */ new Map([
+      ["input-file", a.filename],
+      ["output-file", e.filename]
+    ]);
+    return (await $())(n), e.download();
+  } catch (n) {
+    return console.warn("vf-clamp: OS/2 + macStyle update failed — returning original buffer", n), t;
+  } finally {
+    try {
+      a.delete();
+    } catch {
+    }
+    try {
+      e.delete();
+    } catch {
+    }
+  }
+}
+async function G(t, o) {
+  const a = await l(), e = new u({ pyodide: a }), n = new u({ pyodide: a });
+  try {
+    await e.upload(t);
+    const i = /* @__PURE__ */ new Map([
+      ["input-file", e.filename],
+      ["output-file", n.filename]
+    ]);
+    return (await U())(i, String(o)), n.download();
+  } catch (i) {
+    return console.warn("vf-clamp: wght normalisation failed — returning unnormalised buffer", i), t;
+  } finally {
+    try {
+      e.delete();
+    } catch {
+    }
+    try {
+      n.delete();
+    } catch {
+    }
+  }
+}
+function J(t, o) {
+  const a = new Map(o.map((i) => [i.name, i])), e = {};
+  for (const i of t) {
+    const r = a.get(i);
+    if (!r) throw new Error(`Named instance "${i}" not found in font`);
+    for (const [s, m] of Object.entries(r.coordinates))
+      e[s] ? (e[s].min = Math.min(e[s].min, m), e[s].max = Math.max(e[s].max, m)) : e[s] = { min: m, max: m };
+  }
+  const n = {};
+  for (const [i, { min: r, max: s }] of Object.entries(e))
+    n[i] = r === s ? r : { min: r, max: s };
+  return n;
+}
+async function Z(t, o) {
+  var s, m;
+  if (o.outputs.length === 0) return [];
+  const a = t instanceof ArrayBuffer ? new Uint8Array(t) : t, e = o.format ?? "ttf";
+  let n = [], i = [];
+  if (o.outputs.some((f) => {
+    var p;
+    return (p = f.instances) == null ? void 0 : p.length;
+  })) {
+    const f = await j(a);
+    n = f.instances, i = f.axes;
+  }
+  const r = [];
+  for (const f of o.outputs) {
+    let p = {};
+    (s = f.instances) != null && s.length && (p = J(f.instances, n)), f.axes && (p = { ...p, ...f.axes });
+    for (const d of i) {
+      const x = p[d.tag];
+      if (x != null && typeof x == "object") {
+        const _ = x;
+        if (d.default < _.min || d.default > _.max) {
+          const S = Math.max(_.min, Math.min(_.max, d.default));
+          console.warn(
+            `vf-clamp: axis "${d.tag}" default (${d.default}) is outside restricted range [${_.min}, ${_.max}] — will be clamped to ${S}`
+          );
+        }
+      }
+    }
+    const b = {};
+    for (const [d, x] of Object.entries(p))
+      x !== null && (b[d] = B(x));
+    const F = f.name ?? ((m = f.instances) != null && m.length ? f.instances.length === 1 ? f.instances[0] : `${f.instances[0]}-${f.instances[f.instances.length - 1]}` : "output");
+    let c = await E(a, b);
+    c = await W(c), o.normalizeWeightAxis && (c = await G(c, 100)), c = await q(c), c = await z(c, F), e === "woff2" ? c = await N(c) : e === "woff" && (c = await R(c)), r.push({ name: F, buffer: c, format: e });
+  }
+  return r;
+}
+function K(t, o) {
+  if (t === o) return t;
+  const a = t.split(" "), e = o.split(" ");
+  let n = 0;
+  for (; n < a.length && n < e.length && a[n] === e[n]; )
+    n++;
+  let i = 0;
+  for (; i < a.length - n && i < e.length - n && a[a.length - 1 - i] === e[e.length - 1 - i]; )
+    i++;
+  const r = a.slice(0, n).join(" "), s = a.slice(n, a.length - (i || 0)).join(" "), m = e.slice(n, e.length - (i || 0)).join(" "), f = i > 0 ? a.slice(a.length - i).join(" ") : "", p = s && m ? `${s}-${m}` : s || m;
+  return [r, p, f].filter(Boolean).join(" ");
+}
+export {
+  Z as clampFont,
+  K as compactName,
+  R as convertToWoff,
+  N as convertToWoff2,
+  j as getInstances
+};