@enableai-fonts/core 0.1.3

package/dist/core.cjs.js

@@ -0,0 +1,185 @@
+/**
+* @enableai-fonts/core v0.1.3
+* (c) 2024-present Enableai
+* @license Proprietary
+**/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class FontIconRegistry {
+  constructor(options) {
+    // font mode fields
+    this.fontFamily = "";
+    this.icons = {};
+    this.autoInjectCss = false;
+    this.cssInjected = false;
+    // svg mode fields
+    this.symbolIdPrefix = "icon-";
+    this.spriteUrl = "";
+    this.svgInjected = false;
+    this._initCalled = false;
+    this._initPromise = null;
+    this._svgInitPromise = null;
+    this.options = options;
+    this.icons = options.icons || {};
+    if (options.mode === "font") {
+      this.fontFamily = options.fontFamily;
+      this.classPrefix = options.classPrefix;
+      this.fontSrc = options.fontSrc;
+      this.autoInjectCss = !!options.autoInjectCss;
+    } else {
+      this.spriteUrl = options.fontSrc.sprite;
+    }
+  }
+  get initCalled() {
+    return this._initCalled;
+  }
+  get keys() {
+    return Object.keys(this.icons);
+  }
+  async init() {
+    if (this._initCalled) return true;
+    if (this._initPromise) return this._initPromise;
+    this._initPromise = (async () => {
+      try {
+        if (this.options.mode === "svg") {
+          const ok = await this.initSvgSprite();
+          this._initCalled = ok;
+          return ok;
+        }
+        if (this.fontSrc) {
+          const srcParts = [];
+          if (this.fontSrc.woff) srcParts.push(`url("${this.fontSrc.woff}") format("woff")`);
+          if (this.fontSrc.ttf) srcParts.push(`url("${this.fontSrc.ttf}") format("truetype")`);
+          if (this.fontSrc.svg) srcParts.push(`url("${this.fontSrc.svg}") format("svg")`);
+          if (srcParts.length === 0) {
+            console.warn("[FontIconRegistry] fontSrc provided but empty; falling back to document.fonts.load");
+          } else {
+            const face = new FontFace(this.fontFamily, srcParts.join(", "));
+            const loaded = await face.load();
+            document.fonts.add(loaded);
+          }
+        }
+        if (this.autoInjectCss && this.classPrefix && !this.cssInjected) {
+          this.injectCss();
+        }
+        await document.fonts.load(`1em ${this.fontFamily}`);
+        await document.fonts.ready;
+        this._initCalled = true;
+        return true;
+      } catch (err) {
+        console.error("[FontIconRegistry] init failed:", err);
+        this._initPromise = null;
+        return false;
+      }
+    })();
+    return this._initPromise;
+  }
+  /** SVG: 返回 symbol href，如 "#icon-edit" */
+  getSymbolHref(name) {
+    if (this.options.mode !== "svg") {
+      throw new Error("[FontIconRegistry] getSymbolHref only works in svg mode");
+    }
+    return `#${this.symbolIdPrefix}${String(name)}`;
+  }
+  /** Font: 返回 HTML 可用的 className，例如 "anticon anticon-edit" */
+  getClass(name, extra) {
+    if (this.options.mode !== "font") {
+      throw new Error("[FontIconRegistry] getClass only works in font mode");
+    }
+    const base = this.classPrefix ? this.classPrefix : "";
+    const item = this.classPrefix ? `${this.classPrefix}-${name}` : "";
+    return [base, item, extra].filter(Boolean).join(" ");
+  }
+  /** Font: 返回图标的 hex 码点（不带 \u） */
+  getHex(name) {
+    if (this.options.mode !== "font") {
+      throw new Error("[FontIconRegistry] getHex only works in font mode");
+    }
+    const hex = this.icons[name];
+    if (!hex) throw new Error(`[FontIconRegistry] icon "${name}" not found`);
+    return hex.toLowerCase();
+  }
+  /** Font: 返回可直接渲染的字符 */
+  getChar(name) {
+    const hex = this.getHex(name);
+    const codePoint = parseInt(hex, 16);
+    return String.fromCodePoint(codePoint);
+  }
+  /** Font: 返回 HTML 实体形式，例如 "" */
+  toEntity(name) {
+    return `&#x${this.getHex(name)};`;
+  }
+  async initSvgSprite() {
+    if (this.svgInjected) return true;
+    if (this._svgInitPromise) return this._svgInitPromise;
+    this._svgInitPromise = (async () => {
+      try {
+        if (!this.spriteUrl) return false;
+        const mark = `font-icon-sprite:${this.spriteUrl}`;
+        const selector = `[data-font-icon-sprite="${CSS.escape(mark)}"]`;
+        if (document.querySelector(selector)) {
+          this.svgInjected = true;
+          return true;
+        }
+        const res = await fetch(this.spriteUrl, { credentials: "omit", cache: "force-cache" });
+        if (!res.ok) throw new Error(`fetch sprite failed: ${res.status} ${res.statusText}`);
+        const svgText = await res.text();
+        if (!svgText || !svgText.includes("<svg")) throw new Error("sprite is empty or invalid");
+        const container = document.createElement("div");
+        container.setAttribute("data-font-icon-sprite", mark);
+        container.style.cssText = "position:absolute;width:0;height:0;overflow:hidden;";
+        container.innerHTML = svgText;
+        const svgEl = container.querySelector("svg");
+        if (svgEl) {
+          svgEl.setAttribute("aria-hidden", "true");
+          svgEl.style.position = "absolute";
+          svgEl.style.width = "0";
+          svgEl.style.height = "0";
+          svgEl.style.overflow = "hidden";
+        }
+        const mount = document.body || document.documentElement;
+        mount.insertBefore(container, mount.firstChild);
+        this.svgInjected = true;
+        return true;
+      } catch (err) {
+        console.error("[FontIconRegistry] initSvgSprite failed:", err);
+        this._svgInitPromise = null;
+        return false;
+      }
+    })();
+    return this._svgInitPromise;
+  }
+  injectCss() {
+    if (!this.classPrefix) return;
+    const prefix = this.classPrefix;
+    const style = document.createElement("style");
+    style.setAttribute("data-font-icon", this.fontFamily);
+    const base = `
+.${prefix} {
+  font-family: "${this.fontFamily}" !important;
+  speak: none;
+  font-style: normal;
+  font-weight: normal;
+  font-variant: normal;
+  text-rendering: auto;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+`.trim();
+    const items = Object.entries(this.icons).map(([name, hex]) => {
+      return `.${prefix}-${name}::before { content: "\\${hex}"; }`;
+    });
+    style.textContent = base + "\n" + items.join("\n");
+    document.head.appendChild(style);
+    this.cssInjected = true;
+  }
+}
+
+const ENABLEAI_FONT_STACK = `'Roboto', 'PingFang SC', 'Microsoft YaHei', 'Noto Sans CJK SC', 'Source Han Sans SC', system-ui, -apple-system,
+    BlinkMacSystemFont, 'Segoe UI', 'Helvetica Neue', Arial, 'Apple Color Emoji', 'Segoe UI Emoji', 'Noto Color Emoji',
+    sans-serif`;
+
+exports.ENABLEAI_FONT_STACK = ENABLEAI_FONT_STACK;
+exports.FontIconRegistry = FontIconRegistry;

package/dist/core.cjs.prod.js

@@ -0,0 +1,185 @@
+/**
+* @enableai-fonts/core v0.1.3
+* (c) 2024-present Enableai
+* @license Proprietary
+**/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class FontIconRegistry {
+  constructor(options) {
+    // font mode fields
+    this.fontFamily = "";
+    this.icons = {};
+    this.autoInjectCss = false;
+    this.cssInjected = false;
+    // svg mode fields
+    this.symbolIdPrefix = "icon-";
+    this.spriteUrl = "";
+    this.svgInjected = false;
+    this._initCalled = false;
+    this._initPromise = null;
+    this._svgInitPromise = null;
+    this.options = options;
+    this.icons = options.icons || {};
+    if (options.mode === "font") {
+      this.fontFamily = options.fontFamily;
+      this.classPrefix = options.classPrefix;
+      this.fontSrc = options.fontSrc;
+      this.autoInjectCss = !!options.autoInjectCss;
+    } else {
+      this.spriteUrl = options.fontSrc.sprite;
+    }
+  }
+  get initCalled() {
+    return this._initCalled;
+  }
+  get keys() {
+    return Object.keys(this.icons);
+  }
+  async init() {
+    if (this._initCalled) return true;
+    if (this._initPromise) return this._initPromise;
+    this._initPromise = (async () => {
+      try {
+        if (this.options.mode === "svg") {
+          const ok = await this.initSvgSprite();
+          this._initCalled = ok;
+          return ok;
+        }
+        if (this.fontSrc) {
+          const srcParts = [];
+          if (this.fontSrc.woff) srcParts.push(`url("${this.fontSrc.woff}") format("woff")`);
+          if (this.fontSrc.ttf) srcParts.push(`url("${this.fontSrc.ttf}") format("truetype")`);
+          if (this.fontSrc.svg) srcParts.push(`url("${this.fontSrc.svg}") format("svg")`);
+          if (srcParts.length === 0) {
+            console.warn("[FontIconRegistry] fontSrc provided but empty; falling back to document.fonts.load");
+          } else {
+            const face = new FontFace(this.fontFamily, srcParts.join(", "));
+            const loaded = await face.load();
+            document.fonts.add(loaded);
+          }
+        }
+        if (this.autoInjectCss && this.classPrefix && !this.cssInjected) {
+          this.injectCss();
+        }
+        await document.fonts.load(`1em ${this.fontFamily}`);
+        await document.fonts.ready;
+        this._initCalled = true;
+        return true;
+      } catch (err) {
+        console.error("[FontIconRegistry] init failed:", err);
+        this._initPromise = null;
+        return false;
+      }
+    })();
+    return this._initPromise;
+  }
+  /** SVG: 返回 symbol href，如 "#icon-edit" */
+  getSymbolHref(name) {
+    if (this.options.mode !== "svg") {
+      throw new Error("[FontIconRegistry] getSymbolHref only works in svg mode");
+    }
+    return `#${this.symbolIdPrefix}${String(name)}`;
+  }
+  /** Font: 返回 HTML 可用的 className，例如 "anticon anticon-edit" */
+  getClass(name, extra) {
+    if (this.options.mode !== "font") {
+      throw new Error("[FontIconRegistry] getClass only works in font mode");
+    }
+    const base = this.classPrefix ? this.classPrefix : "";
+    const item = this.classPrefix ? `${this.classPrefix}-${name}` : "";
+    return [base, item, extra].filter(Boolean).join(" ");
+  }
+  /** Font: 返回图标的 hex 码点（不带 \u） */
+  getHex(name) {
+    if (this.options.mode !== "font") {
+      throw new Error("[FontIconRegistry] getHex only works in font mode");
+    }
+    const hex = this.icons[name];
+    if (!hex) throw new Error(`[FontIconRegistry] icon "${name}" not found`);
+    return hex.toLowerCase();
+  }
+  /** Font: 返回可直接渲染的字符 */
+  getChar(name) {
+    const hex = this.getHex(name);
+    const codePoint = parseInt(hex, 16);
+    return String.fromCodePoint(codePoint);
+  }
+  /** Font: 返回 HTML 实体形式，例如 "" */
+  toEntity(name) {
+    return `&#x${this.getHex(name)};`;
+  }
+  async initSvgSprite() {
+    if (this.svgInjected) return true;
+    if (this._svgInitPromise) return this._svgInitPromise;
+    this._svgInitPromise = (async () => {
+      try {
+        if (!this.spriteUrl) return false;
+        const mark = `font-icon-sprite:${this.spriteUrl}`;
+        const selector = `[data-font-icon-sprite="${CSS.escape(mark)}"]`;
+        if (document.querySelector(selector)) {
+          this.svgInjected = true;
+          return true;
+        }
+        const res = await fetch(this.spriteUrl, { credentials: "omit", cache: "force-cache" });
+        if (!res.ok) throw new Error(`fetch sprite failed: ${res.status} ${res.statusText}`);
+        const svgText = await res.text();
+        if (!svgText || !svgText.includes("<svg")) throw new Error("sprite is empty or invalid");
+        const container = document.createElement("div");
+        container.setAttribute("data-font-icon-sprite", mark);
+        container.style.cssText = "position:absolute;width:0;height:0;overflow:hidden;";
+        container.innerHTML = svgText;
+        const svgEl = container.querySelector("svg");
+        if (svgEl) {
+          svgEl.setAttribute("aria-hidden", "true");
+          svgEl.style.position = "absolute";
+          svgEl.style.width = "0";
+          svgEl.style.height = "0";
+          svgEl.style.overflow = "hidden";
+        }
+        const mount = document.body || document.documentElement;
+        mount.insertBefore(container, mount.firstChild);
+        this.svgInjected = true;
+        return true;
+      } catch (err) {
+        console.error("[FontIconRegistry] initSvgSprite failed:", err);
+        this._svgInitPromise = null;
+        return false;
+      }
+    })();
+    return this._svgInitPromise;
+  }
+  injectCss() {
+    if (!this.classPrefix) return;
+    const prefix = this.classPrefix;
+    const style = document.createElement("style");
+    style.setAttribute("data-font-icon", this.fontFamily);
+    const base = `
+.${prefix} {
+  font-family: "${this.fontFamily}" !important;
+  speak: none;
+  font-style: normal;
+  font-weight: normal;
+  font-variant: normal;
+  text-rendering: auto;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+`.trim();
+    const items = Object.entries(this.icons).map(([name, hex]) => {
+      return `.${prefix}-${name}::before { content: "\\${hex}"; }`;
+    });
+    style.textContent = base + "\n" + items.join("\n");
+    document.head.appendChild(style);
+    this.cssInjected = true;
+  }
+}
+
+const ENABLEAI_FONT_STACK = `'Roboto', 'PingFang SC', 'Microsoft YaHei', 'Noto Sans CJK SC', 'Source Han Sans SC', system-ui, -apple-system,
+    BlinkMacSystemFont, 'Segoe UI', 'Helvetica Neue', Arial, 'Apple Color Emoji', 'Segoe UI Emoji', 'Noto Color Emoji',
+    sans-serif`;
+
+exports.ENABLEAI_FONT_STACK = ENABLEAI_FONT_STACK;
+exports.FontIconRegistry = FontIconRegistry;

package/dist/core.css

@@ -0,0 +1,10 @@
+:root {
+  --font-sans:
+    'Roboto', 'PingFang SC', 'Microsoft YaHei', 'Noto Sans CJK SC', 'Source Han Sans SC', system-ui, -apple-system,
+    BlinkMacSystemFont, 'Segoe UI', 'Helvetica Neue', Arial, 'Apple Color Emoji', 'Segoe UI Emoji', 'Noto Color Emoji',
+    sans-serif;
+}
+
+body {
+  font-family: var(--font-sans);
+}

package/dist/core.d.ts

@@ -0,0 +1,58 @@
+type IconMap<Key extends string> = Record<Key, string>;
+type FontSrc = {
+    woff?: string;
+    ttf?: string;
+    svg?: string;
+};
+type SvgSpriteSrc = {
+    /** sprite.svg 的 URL（由 iconfont js 抽出来的那个） */
+    sprite: string;
+};
+type FontModeOptions<Key extends string> = {
+    mode: 'font';
+    fontFamily: string;
+    icons: IconMap<Key>;
+    classPrefix?: string;
+    fontSrc?: FontSrc;
+    autoInjectCss?: boolean;
+};
+type SvgModeOptions<Key extends string> = {
+    mode: 'svg';
+    icons: IconMap<Key>;
+    fontSrc: SvgSpriteSrc;
+};
+type Options<Key extends string> = FontModeOptions<Key> | SvgModeOptions<Key>;
+export declare class FontIconRegistry<Key extends string> {
+    private options;
+    private fontFamily;
+    private icons;
+    private classPrefix?;
+    private fontSrc?;
+    private autoInjectCss;
+    private cssInjected;
+    private symbolIdPrefix;
+    private spriteUrl;
+    private svgInjected;
+    private _initCalled;
+    get initCalled(): boolean;
+    private _initPromise;
+    private _svgInitPromise;
+    constructor(options: Options<Key>);
+    get keys(): Key[];
+    init(): Promise<boolean>;
+    /** SVG: 返回 symbol href，如 "#icon-edit" */
+    getSymbolHref(name: Key): string;
+    /** Font: 返回 HTML 可用的 className，例如 "anticon anticon-edit" */
+    getClass(name: Key, extra?: string): string;
+    /** Font: 返回图标的 hex 码点（不带 \u） */
+    getHex(name: Key): string;
+    /** Font: 返回可直接渲染的字符 */
+    getChar(name: Key): string;
+    /** Font: 返回 HTML 实体形式，例如 "&#xe600;" */
+    toEntity(name: Key): string;
+    private initSvgSprite;
+    private injectCss;
+}
+
+export declare const ENABLEAI_FONT_STACK = "'Roboto', 'PingFang SC', 'Microsoft YaHei', 'Noto Sans CJK SC', 'Source Han Sans SC', system-ui, -apple-system,\n    BlinkMacSystemFont, 'Segoe UI', 'Helvetica Neue', Arial, 'Apple Color Emoji', 'Segoe UI Emoji', 'Noto Color Emoji',\n    sans-serif";
+

package/dist/core.esm-bundler.mjs

@@ -0,0 +1,180 @@
+/**
+* @enableai-fonts/core v0.1.3
+* (c) 2024-present Enableai
+* @license Proprietary
+**/
+class FontIconRegistry {
+  constructor(options) {
+    // font mode fields
+    this.fontFamily = "";
+    this.icons = {};
+    this.autoInjectCss = false;
+    this.cssInjected = false;
+    // svg mode fields
+    this.symbolIdPrefix = "icon-";
+    this.spriteUrl = "";
+    this.svgInjected = false;
+    this._initCalled = false;
+    this._initPromise = null;
+    this._svgInitPromise = null;
+    this.options = options;
+    this.icons = options.icons || {};
+    if (options.mode === "font") {
+      this.fontFamily = options.fontFamily;
+      this.classPrefix = options.classPrefix;
+      this.fontSrc = options.fontSrc;
+      this.autoInjectCss = !!options.autoInjectCss;
+    } else {
+      this.spriteUrl = options.fontSrc.sprite;
+    }
+  }
+  get initCalled() {
+    return this._initCalled;
+  }
+  get keys() {
+    return Object.keys(this.icons);
+  }
+  async init() {
+    if (this._initCalled) return true;
+    if (this._initPromise) return this._initPromise;
+    this._initPromise = (async () => {
+      try {
+        if (this.options.mode === "svg") {
+          const ok = await this.initSvgSprite();
+          this._initCalled = ok;
+          return ok;
+        }
+        if (this.fontSrc) {
+          const srcParts = [];
+          if (this.fontSrc.woff) srcParts.push(`url("${this.fontSrc.woff}") format("woff")`);
+          if (this.fontSrc.ttf) srcParts.push(`url("${this.fontSrc.ttf}") format("truetype")`);
+          if (this.fontSrc.svg) srcParts.push(`url("${this.fontSrc.svg}") format("svg")`);
+          if (srcParts.length === 0) {
+            console.warn("[FontIconRegistry] fontSrc provided but empty; falling back to document.fonts.load");
+          } else {
+            const face = new FontFace(this.fontFamily, srcParts.join(", "));
+            const loaded = await face.load();
+            document.fonts.add(loaded);
+          }
+        }
+        if (this.autoInjectCss && this.classPrefix && !this.cssInjected) {
+          this.injectCss();
+        }
+        await document.fonts.load(`1em ${this.fontFamily}`);
+        await document.fonts.ready;
+        this._initCalled = true;
+        return true;
+      } catch (err) {
+        console.error("[FontIconRegistry] init failed:", err);
+        this._initPromise = null;
+        return false;
+      }
+    })();
+    return this._initPromise;
+  }
+  /** SVG: 返回 symbol href，如 "#icon-edit" */
+  getSymbolHref(name) {
+    if (this.options.mode !== "svg") {
+      throw new Error("[FontIconRegistry] getSymbolHref only works in svg mode");
+    }
+    return `#${this.symbolIdPrefix}${String(name)}`;
+  }
+  /** Font: 返回 HTML 可用的 className，例如 "anticon anticon-edit" */
+  getClass(name, extra) {
+    if (this.options.mode !== "font") {
+      throw new Error("[FontIconRegistry] getClass only works in font mode");
+    }
+    const base = this.classPrefix ? this.classPrefix : "";
+    const item = this.classPrefix ? `${this.classPrefix}-${name}` : "";
+    return [base, item, extra].filter(Boolean).join(" ");
+  }
+  /** Font: 返回图标的 hex 码点（不带 \u） */
+  getHex(name) {
+    if (this.options.mode !== "font") {
+      throw new Error("[FontIconRegistry] getHex only works in font mode");
+    }
+    const hex = this.icons[name];
+    if (!hex) throw new Error(`[FontIconRegistry] icon "${name}" not found`);
+    return hex.toLowerCase();
+  }
+  /** Font: 返回可直接渲染的字符 */
+  getChar(name) {
+    const hex = this.getHex(name);
+    const codePoint = parseInt(hex, 16);
+    return String.fromCodePoint(codePoint);
+  }
+  /** Font: 返回 HTML 实体形式，例如 "" */
+  toEntity(name) {
+    return `&#x${this.getHex(name)};`;
+  }
+  async initSvgSprite() {
+    if (this.svgInjected) return true;
+    if (this._svgInitPromise) return this._svgInitPromise;
+    this._svgInitPromise = (async () => {
+      try {
+        if (!this.spriteUrl) return false;
+        const mark = `font-icon-sprite:${this.spriteUrl}`;
+        const selector = `[data-font-icon-sprite="${CSS.escape(mark)}"]`;
+        if (document.querySelector(selector)) {
+          this.svgInjected = true;
+          return true;
+        }
+        const res = await fetch(this.spriteUrl, { credentials: "omit", cache: "force-cache" });
+        if (!res.ok) throw new Error(`fetch sprite failed: ${res.status} ${res.statusText}`);
+        const svgText = await res.text();
+        if (!svgText || !svgText.includes("<svg")) throw new Error("sprite is empty or invalid");
+        const container = document.createElement("div");
+        container.setAttribute("data-font-icon-sprite", mark);
+        container.style.cssText = "position:absolute;width:0;height:0;overflow:hidden;";
+        container.innerHTML = svgText;
+        const svgEl = container.querySelector("svg");
+        if (svgEl) {
+          svgEl.setAttribute("aria-hidden", "true");
+          svgEl.style.position = "absolute";
+          svgEl.style.width = "0";
+          svgEl.style.height = "0";
+          svgEl.style.overflow = "hidden";
+        }
+        const mount = document.body || document.documentElement;
+        mount.insertBefore(container, mount.firstChild);
+        this.svgInjected = true;
+        return true;
+      } catch (err) {
+        console.error("[FontIconRegistry] initSvgSprite failed:", err);
+        this._svgInitPromise = null;
+        return false;
+      }
+    })();
+    return this._svgInitPromise;
+  }
+  injectCss() {
+    if (!this.classPrefix) return;
+    const prefix = this.classPrefix;
+    const style = document.createElement("style");
+    style.setAttribute("data-font-icon", this.fontFamily);
+    const base = `
+.${prefix} {
+  font-family: "${this.fontFamily}" !important;
+  speak: none;
+  font-style: normal;
+  font-weight: normal;
+  font-variant: normal;
+  text-rendering: auto;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+`.trim();
+    const items = Object.entries(this.icons).map(([name, hex]) => {
+      return `.${prefix}-${name}::before { content: "\\${hex}"; }`;
+    });
+    style.textContent = base + "\n" + items.join("\n");
+    document.head.appendChild(style);
+    this.cssInjected = true;
+  }
+}
+
+const ENABLEAI_FONT_STACK = `'Roboto', 'PingFang SC', 'Microsoft YaHei', 'Noto Sans CJK SC', 'Source Han Sans SC', system-ui, -apple-system,
+    BlinkMacSystemFont, 'Segoe UI', 'Helvetica Neue', Arial, 'Apple Color Emoji', 'Segoe UI Emoji', 'Noto Color Emoji',
+    sans-serif`;
+
+export { ENABLEAI_FONT_STACK, FontIconRegistry };

package/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/core.cjs.prod.js')
+} else {
+  module.exports = require('./dist/core.cjs.js')
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@enableai-fonts/core",
+  "version": "0.1.3",
+  "order": 1,
+  "description": "",
+  "main": "index.js",
+  "types": "dist/core.d.ts",
+  "files": [
+    "dist",
+    "index.js"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/core.d.ts",
+      "module": "./dist/core.esm-bundler.mjs",
+      "import": "./dist/core.esm-bundler.mjs",
+      "require": "./index.js"
+    },
+    "./*": "./*",
+    "./styles.css": "./dist/core.css"
+  },
+  "buildOptions": {
+    "name": "core",
+    "formats": [
+      "esm-bundler",
+      "cjs"
+    ]
+  },
+  "keywords": [],
+  "license": "Proprietary",
+  "dependencies": {
+    "@fontsource/roboto": "^5.2.9"
+  }
+}