@hanzogui/static 2.0.0-rc.41-hanzoai.5

package/dist/extractor/extractMediaStyle.cjs

@@ -0,0 +1,169 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var extractMediaStyle_exports = {};
+__export(extractMediaStyle_exports, {
+  extractMediaStyle: () => extractMediaStyle,
+  isValidMediaCall: () => isValidMediaCall
+});
+module.exports = __toCommonJS(extractMediaStyle_exports);
+var t = __toESM(require("@babel/types"));
+var core = __toESM(require("@hanzogui/core"));
+var import_requireHanzoguiCore = require("../helpers/requireHanzoguiCore.cjs");
+var import_extractHelpers = require("./extractHelpers.cjs");
+function extractMediaStyle(props, ternary, jsxPath, hanzoguiConfig, sourcePath, importance = 0, shouldPrintDebug = false) {
+  const {
+    getCSSStylesAtomic
+  } = (0, import_requireHanzoguiCore.requireHanzoguiCore)("web");
+  const mt = getMediaQueryTernary(props, ternary, jsxPath, sourcePath);
+  if (!mt) {
+    return null;
+  }
+  const {
+    key
+  } = mt;
+  const mq = hanzoguiConfig.media[key];
+  if (!mq) {
+    console.error(`Media query "${key}" not found: ${Object.keys(hanzoguiConfig.media)}`);
+    return null;
+  }
+  const getStyleObj = (styleObj, negate = false) => {
+    return styleObj ? {
+      styleObj,
+      negate
+    } : null;
+  };
+  const styleOpts = [getStyleObj(ternary.consequent, false), getStyleObj(ternary.alternate, true)].filter(import_extractHelpers.isPresent);
+  if (shouldPrintDebug && !styleOpts.length) {
+    console.info("  media query, no styles?");
+    return null;
+  }
+  const mediaKeys = Object.keys(hanzoguiConfig.media);
+  const mediaKeyPrecendence = mediaKeys.reduce((acc, cur, i) => {
+    acc[cur] = new Array(importance + 1).fill(":root").join("");
+    return acc;
+  }, {});
+  let mediaStyles = [];
+  for (const {
+    styleObj,
+    negate
+  } of styleOpts) {
+    const styles = getCSSStylesAtomic(styleObj);
+    const singleMediaStyles = styles.map(style => {
+      const mediaStyle = core.createMediaStyle(style, key, hanzoguiConfig.media, true, negate);
+      const className = `.${mediaStyle[core.StyleObjectIdentifier]}`;
+      return {
+        ...mediaStyle,
+        className
+      };
+    });
+    if (shouldPrintDebug === "verbose") {
+      console.info("  media styles:", importance, styleObj, singleMediaStyles.map(x => x[core.StyleObjectIdentifier]).join(", "));
+    }
+    mediaStyles = [...mediaStyles, ...singleMediaStyles];
+  }
+  ternary.remove();
+  return {
+    mediaStyles,
+    ternaryWithoutMedia: mt.ternaryWithoutMedia
+  };
+}
+function getMediaQueryTernary(props, ternary, jsxPath, sourcePath) {
+  if (t.isLogicalExpression(ternary.test) && ternary.test.operator === "&&") {
+    const mediaLeft = getMediaInfoFromExpression(props, ternary.test.left, jsxPath, sourcePath, ternary.inlineMediaQuery);
+    if (mediaLeft) {
+      return {
+        ...mediaLeft,
+        ternaryWithoutMedia: {
+          ...ternary,
+          test: ternary.test.right
+        }
+      };
+    }
+  }
+  const result = getMediaInfoFromExpression(props, ternary.test, jsxPath, sourcePath, ternary.inlineMediaQuery);
+  if (result) {
+    return {
+      ...result,
+      ternaryWithoutMedia: null
+    };
+  }
+  return null;
+}
+function getMediaInfoFromExpression(props, test, jsxPath, sourcePath, inlineMediaQuery) {
+  if (inlineMediaQuery) {
+    return {
+      key: inlineMediaQuery,
+      bindingName: inlineMediaQuery
+    };
+  }
+  if (t.isMemberExpression(test) && t.isIdentifier(test.object) && t.isIdentifier(test.property)) {
+    const name = test.object["name"];
+    const key = test.property["name"];
+    const bindings = jsxPath.scope.getAllBindings();
+    const binding = bindings[name];
+    if (!binding) return false;
+    const bindingNode = binding.path?.node;
+    if (!t.isVariableDeclarator(bindingNode) || !bindingNode.init) return false;
+    if (!isValidMediaCall(props, jsxPath, bindingNode.init, sourcePath)) return false;
+    return {
+      key,
+      bindingName: name
+    };
+  }
+  if (t.isIdentifier(test)) {
+    const key = test.name;
+    const node = jsxPath.scope.getBinding(test.name)?.path?.node;
+    if (!t.isVariableDeclarator(node)) return false;
+    if (!node.init || !isValidMediaCall(props, jsxPath, node.init, sourcePath)) return false;
+    return {
+      key,
+      bindingName: key
+    };
+  }
+  return null;
+}
+function isValidMediaCall(props, jsxPath, init, sourcePath) {
+  if (!init || !t.isCallExpression(init)) return false;
+  if (!t.isIdentifier(init.callee)) return false;
+  if (init.callee.name !== "useMedia") return false;
+  const bindings = jsxPath.scope.getAllBindings();
+  const mediaBinding = bindings["useMedia"];
+  if (!mediaBinding) return false;
+  const useMediaImport = mediaBinding.path.parent;
+  if (!t.isImportDeclaration(useMediaImport)) return false;
+  if (!(0, import_extractHelpers.isValidImport)(props, sourcePath)) {
+    return false;
+  }
+  return true;
+}

package/dist/extractor/extractToClassNames.cjs

@@ -0,0 +1,427 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var extractToClassNames_exports = {};
+__export(extractToClassNames_exports, {
+  extractToClassNames: () => extractToClassNames
+});
+module.exports = __toCommonJS(extractToClassNames_exports);
+var import_generator = __toESM(require("@babel/generator"));
+var t = __toESM(require("@babel/types"));
+var import_web = require("@hanzogui/web");
+var path = __toESM(require("node:path"));
+var util = __toESM(require("node:util"));
+var import_requireHanzoguiCore = require("../helpers/requireHanzoguiCore.cjs");
+var import_babelParse = require("./babelParse.cjs");
+var import_createLogger = require("./createLogger.cjs");
+var import_extractMediaStyle = require("./extractMediaStyle.cjs");
+var import_normalizeTernaries = require("./normalizeTernaries.cjs");
+var import_propsToFontFamilyCache = require("./propsToFontFamilyCache.cjs");
+var import_timer = require("./timer.cjs");
+var import_errors = require("./errors.cjs");
+var import_concatClassName = require("./concatClassName.cjs");
+const remove = () => {};
+const spaceString = t.stringLiteral(" ");
+async function extractToClassNames({
+  extractor,
+  source,
+  sourcePath = "",
+  options,
+  shouldPrintDebug
+}) {
+  const tm = (0, import_timer.timer)();
+  const {
+    getCSSStylesAtomic,
+    createMediaStyle
+  } = (0, import_requireHanzoguiCore.requireHanzoguiCore)("web");
+  if (sourcePath.includes("node_modules")) {
+    return null;
+  }
+  if (shouldPrintDebug) {
+    console.warn(`--- ${sourcePath} --- 
+
+`);
+  }
+  if (typeof source !== "string") {
+    throw new Error("`source` must be a string of javascript");
+  }
+  if (!path.isAbsolute(sourcePath)) {
+    throw new Error("`sourcePath` must be an absolute path to a .js file, got: " + sourcePath);
+  }
+  if (!/.[tj]sx?$/i.test(sourcePath || "")) {
+    console.warn(`${sourcePath.slice(0, 100)} - bad filename.`);
+  }
+  if (!options.disableExtraction && !options["_disableLoadHanzogui"]) {
+    await extractor.loadHanzogui(options);
+  }
+  const printLog = (0, import_createLogger.createLogger)(sourcePath, options);
+  let ast;
+  try {
+    ast = (0, import_babelParse.babelParse)(source, sourcePath);
+  } catch (err) {
+    console.error("babel parse error:", sourcePath.slice(0, 100));
+    throw err;
+  }
+  tm.mark(`babel-parse`, shouldPrintDebug === "verbose");
+  const cssMap = /* @__PURE__ */new Map();
+  const hanzoguiConfig = extractor.getHanzogui();
+  const res = await extractor.parse(ast, {
+    shouldPrintDebug,
+    ...options,
+    platform: "web",
+    sourcePath,
+    extractStyledDefinitions: true,
+    onStyledDefinitionRule(identifier, rules) {
+      const css = rules.join("\n");
+      if (shouldPrintDebug) {
+        console.info(`adding styled() rule: .${identifier} ${css}`);
+      }
+      cssMap.set(`.${identifier}`, {
+        css,
+        commentTexts: []
+      });
+    },
+    getFlattenedNode: ({
+      tag
+    }) => {
+      return tag;
+    },
+    onExtractTag: ({
+      parserProps,
+      attrs,
+      node,
+      attemptEval,
+      jsxPath,
+      originalNodeName,
+      filePath,
+      lineNumbers,
+      staticConfig
+    }) => {
+      if (staticConfig.acceptsClassName === false) {
+        throw new import_errors.BailOptimizationError();
+      }
+      const finalAttrs = [];
+      let mergeForwardBaseStyle = null;
+      let attrClassName = null;
+      let baseFontFamily = "";
+      let mediaStylesSeen = 1;
+      const comment = util.format("/* %s:%s (%s) */", filePath, lineNumbers, originalNodeName);
+      function addStyle(style) {
+        const identifier = style[import_web.StyleObjectIdentifier];
+        const rules = style[import_web.StyleObjectRules];
+        const selector = `.${identifier}`;
+        if (cssMap.has(selector)) {
+          const val = cssMap.get(selector);
+          val.commentTexts.push(comment);
+        } else if (rules.length) {
+          cssMap.set(selector, {
+            css: rules.join("\n"),
+            commentTexts: [comment]
+          });
+        }
+        return identifier;
+      }
+      function addStyles(style) {
+        const cssStyles = getCSSStylesAtomic(style);
+        const classNames = [];
+        for (const style2 of cssStyles) {
+          const property = style2[0];
+          const mediaName = property.slice(1);
+          if (mediaName.startsWith("group-")) {
+            throw new import_errors.BailOptimizationError();
+          }
+          const mediaTypeMatch = mediaName.match(/^(theme|platform)-/);
+          if (mediaTypeMatch) {
+            const mediaType = mediaTypeMatch[1];
+            const mediaStyle = createMediaStyle(style2, mediaName, extractor.getHanzogui().media, mediaType, false, mediaStylesSeen);
+            const identifier2 = addStyle(mediaStyle);
+            classNames.push(identifier2);
+            continue;
+          }
+          if (mediaName in hanzoguiConfig.media) {
+            const mediaStyle = createMediaStyle(style2, mediaName, extractor.getHanzogui().media, true, false, mediaStylesSeen);
+            const identifier2 = addStyle(mediaStyle);
+            classNames.push(identifier2);
+            continue;
+          }
+          const identifier = addStyle(style2);
+          classNames.push(identifier);
+        }
+        return classNames;
+      }
+      const onlyTernaries = attrs.flatMap(attr => {
+        if (attr.type === "attr") {
+          const value = attr.value;
+          if (t.isJSXSpreadAttribute(value)) {
+            console.error(`Should never happen`);
+            return [];
+          }
+          if (value.name.name === "className") {
+            let inner = value.value;
+            if (t.isJSXExpressionContainer(inner)) {
+              inner = inner.expression;
+            }
+            try {
+              const evaluatedValue = inner ? attemptEval(inner) : null;
+              if (typeof evaluatedValue === "string") {
+                attrClassName = t.stringLiteral(evaluatedValue);
+              }
+            } catch (e) {
+              if (inner) {
+                attrClassName ||= inner;
+              }
+            }
+            return [];
+          }
+          finalAttrs.push(value);
+          return [];
+        }
+        if (attr.type === "style") {
+          mergeForwardBaseStyle = (0, import_web.mergeProps)(mergeForwardBaseStyle || {}, attr.value);
+          baseFontFamily = (0, import_propsToFontFamilyCache.getFontFamilyNameFromProps)(attr.value) || "";
+          return [];
+        }
+        let ternary = attr.value;
+        if (ternary.inlineMediaQuery) {
+          const mediaExtraction = (0, import_extractMediaStyle.extractMediaStyle)(parserProps, attr.value, jsxPath, extractor.getHanzogui(), sourcePath || "", mediaStylesSeen++, shouldPrintDebug);
+          if (mediaExtraction) {
+            if (mediaExtraction.mediaStyles) {
+              mergeForwardBaseStyle = (0, import_web.mergeProps)(mergeForwardBaseStyle || {}, {
+                [`$${ternary.inlineMediaQuery}`]: attr.value.consequent
+              });
+            }
+            if (mediaExtraction.ternaryWithoutMedia) {
+              ternary = mediaExtraction.ternaryWithoutMedia;
+            } else {
+              return [];
+            }
+          }
+        }
+        let mergedAlternate;
+        let mergedConsequent;
+        if (ternary.alternate && Object.keys(ternary.alternate).length) {
+          mergedAlternate = (0, import_web.mergeProps)(mergeForwardBaseStyle || {}, ternary.alternate || {});
+          (0, import_propsToFontFamilyCache.forwardFontFamilyName)(ternary.alternate, mergedAlternate, baseFontFamily);
+        }
+        if (ternary.consequent && Object.keys(ternary.consequent).length) {
+          mergedConsequent = (0, import_web.mergeProps)(mergeForwardBaseStyle || {}, ternary.consequent || {});
+          (0, import_propsToFontFamilyCache.forwardFontFamilyName)(ternary.consequent, mergedConsequent, baseFontFamily);
+        }
+        return {
+          ...ternary,
+          alternate: mergedAlternate,
+          consequent: mergedConsequent
+        };
+      });
+      const hasTernaries = Boolean(onlyTernaries.length);
+      const baseClassNames = mergeForwardBaseStyle ? addStyles(mergeForwardBaseStyle) : null;
+      let baseClassNameStr = !baseClassNames ? "" : baseClassNames.join(" ");
+      if (baseFontFamily) {
+        baseClassNameStr = `font_${baseFontFamily}${baseClassNameStr ? ` ${baseClassNameStr}` : ""}`;
+      }
+      const baseTypeClass = staticConfig.isText ? "is_Text" : "is_View";
+      baseClassNameStr = `${baseTypeClass}${baseClassNameStr ? ` ${baseClassNameStr}` : ""}`;
+      const componentNameFinal = staticConfig.componentName;
+      let base = componentNameFinal && componentNameFinal !== "Text" ? t.stringLiteral(`is_${componentNameFinal}${baseClassNameStr ? ` ${baseClassNameStr}` : ""}`) : t.stringLiteral(baseClassNameStr || "");
+      attrClassName = attrClassName;
+      const baseClassNameExpression = (() => {
+        if (attrClassName) {
+          if (t.isStringLiteral(attrClassName)) {
+            return t.stringLiteral(base.value ? `${base.value} ${attrClassName.value}` : attrClassName.value);
+          } else {
+            return t.binaryExpression("+", t.binaryExpression("+", attrClassName, spaceString), base);
+          }
+        }
+        return base;
+      })();
+      const expandedTernaries = [];
+      if (onlyTernaries.length) {
+        const normalizedTernaries = (0, import_normalizeTernaries.normalizeTernaries)(onlyTernaries);
+        for (const ternary of normalizedTernaries) {
+          if (!expandedTernaries.length) {
+            expandTernary(ternary);
+            continue;
+          }
+          const prevTernaries = [...expandedTernaries];
+          for (const prev of prevTernaries) {
+            expandTernary(ternary, prev);
+          }
+        }
+      }
+      function expandTernary(ternary, prev) {
+        if (ternary.consequent && Object.keys(ternary.consequent).length) {
+          const fontFamily = (0, import_propsToFontFamilyCache.getFontFamilyNameFromProps)(ternary.consequent);
+          expandedTernaries.push({
+            fontFamily,
+            // prevTest && test: merge consequent
+            test: prev ? t.logicalExpression("&&", prev.test, ternary.test) : ternary.test,
+            consequent: prev ? (0, import_web.mergeProps)(prev.consequent, ternary.consequent) : ternary.consequent,
+            remove,
+            alternate: null
+          });
+          if (prev) {
+            expandedTernaries.push({
+              fontFamily,
+              // !prevTest && test: just consequent
+              test: t.logicalExpression("&&", t.unaryExpression("!", prev.test), ternary.test),
+              consequent: ternary.consequent,
+              alternate: null,
+              remove
+            });
+          }
+        }
+        if (ternary.alternate && Object.keys(ternary.alternate).length) {
+          const fontFamily = (0, import_propsToFontFamilyCache.getFontFamilyNameFromProps)(ternary.alternate);
+          const negated = t.unaryExpression("!", ternary.test);
+          expandedTernaries.push({
+            fontFamily,
+            // prevTest && !test: merge alternate
+            test: prev ? t.logicalExpression("&&", prev.test, negated) : negated,
+            consequent: prev ? (0, import_web.mergeProps)(prev.alternate, ternary.alternate) : ternary.alternate,
+            remove,
+            alternate: null
+          });
+          if (prev) {
+            expandedTernaries.push({
+              fontFamily,
+              test: t.logicalExpression("&&", t.unaryExpression("!", prev.test), ternary.test),
+              consequent: ternary.alternate,
+              remove,
+              alternate: null
+            });
+          }
+        }
+      }
+      let ternaryClassNameExpr = null;
+      if (hasTernaries) {
+        for (const ternary of expandedTernaries) {
+          if (!ternary.consequent) continue;
+          const classNames = addStyles(ternary.consequent);
+          if (ternary.fontFamily) {
+            classNames.unshift(`font_${ternary.fontFamily}`);
+          }
+          const baseString = t.isStringLiteral(baseClassNameExpression) ? baseClassNameExpression.value : "";
+          const fullClassNameWithDups = (baseString ? `${baseString} ` : "") + classNames.join(" ");
+          const fullClassName = (0, import_concatClassName.concatClassName)(fullClassNameWithDups);
+          const classNameLiteral = t.stringLiteral(fullClassName);
+          if (!ternaryClassNameExpr) {
+            ternaryClassNameExpr = t.conditionalExpression(ternary.test, classNameLiteral, baseClassNameExpression);
+          } else {
+            ternaryClassNameExpr = t.conditionalExpression(ternary.test, classNameLiteral, ternaryClassNameExpr);
+          }
+        }
+      }
+      let finalExpression = ternaryClassNameExpr || baseClassNameExpression || null;
+      if (shouldPrintDebug) {
+        console.info("attrs", JSON.stringify(attrs, null, 2));
+        console.info("expandedTernaries", JSON.stringify(expandedTernaries, null, 2));
+        console.info("finalExpression", JSON.stringify(finalExpression, null, 2));
+        console.info({
+          hasTernaries,
+          baseClassNameExpression
+        });
+      }
+      if (finalExpression) {
+        finalExpression = hoistClassNames(jsxPath, finalExpression);
+        const classNameProp = t.jsxAttribute(t.jsxIdentifier("className"), t.jsxExpressionContainer(finalExpression));
+        finalAttrs.unshift(classNameProp);
+      }
+      node.attributes = finalAttrs;
+    }
+  });
+  if (!res || !res.modified && !res.optimized && !res.flattened && !res.styled) {
+    if (shouldPrintDebug) {
+      console.info("no res or none modified", res);
+    }
+    return null;
+  }
+  const styles = Array.from(cssMap.values()).map(x => x.css).join("\n").trim();
+  const result = (0, import_generator.default)(ast, {
+    concise: false,
+    filename: sourcePath,
+    // this makes the debug output terrible, and i think sourcemap works already
+    retainLines: false,
+    sourceFileName: sourcePath,
+    sourceMaps: true
+  }, source);
+  if (shouldPrintDebug) {
+    console.info("\n -------- output code ------- \n\n", result.code.split("\n").filter(x => !x.startsWith("//")).join("\n"));
+    console.info("\n -------- output style -------- \n\n", styles);
+  }
+  printLog(res);
+  return {
+    ast,
+    styles,
+    js: result.code,
+    map: result.map,
+    stats: {
+      styled: res.styled,
+      flattened: res.flattened,
+      optimized: res.optimized,
+      found: res.found
+    }
+  };
+}
+function hoistClassNames(path2, expr) {
+  if (t.isStringLiteral(expr)) {
+    return hoistClassName(path2, expr.value);
+  }
+  if (t.isLogicalExpression(expr)) {
+    const left = t.isStringLiteral(expr.left) ? hoistClassName(path2, expr.left.value) : expr.left;
+    const right = t.isStringLiteral(expr.right) ? hoistClassName(path2, expr.right.value) : hoistClassNames(path2, expr.right);
+    return t.logicalExpression(expr.operator, left, right);
+  }
+  if (t.isConditionalExpression(expr)) {
+    const cons = t.isStringLiteral(expr.consequent) ? hoistClassName(path2, expr.consequent.value) : hoistClassNames(path2, expr.consequent);
+    const alt = t.isStringLiteral(expr.alternate) ? hoistClassName(path2, expr.alternate.value) : hoistClassNames(path2, expr.alternate);
+    return t.conditionalExpression(expr.test, cons, alt);
+  }
+  return expr;
+}
+function hoistClassName(path2, str) {
+  const uid = path2.scope.generateUidIdentifier("cn");
+  const parent = path2.findParent(path3 => path3.isProgram());
+  if (!parent) throw new Error(`no program?`);
+  const variable = t.variableDeclaration("const", [t.variableDeclarator(uid, t.stringLiteral(cleanupClassName(str)))]);
+  parent.unshiftContainer("body", variable);
+  return uid;
+}
+function cleanupClassName(inStr) {
+  const out = /* @__PURE__ */new Set();
+  for (const part of inStr.split(" ")) {
+    if (!part || part === " ") continue;
+    if (part === "font_") continue;
+    out.add(part);
+  }
+  return [...out].join(" ");
+}