@unocss/core 0.1.0-beta.2

package/dist/index.mjs

@@ -0,0 +1,661 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/utils/escape.ts
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeSelector(str) {
+  const length = str.length;
+  let index = -1;
+  let codeUnit;
+  let result = "";
+  const firstCodeUnit = str.charCodeAt(0);
+  while (++index < length) {
+    codeUnit = str.charCodeAt(index);
+    if (codeUnit === 0) {
+      result += "\uFFFD";
+      continue;
+    }
+    if (codeUnit === 44) {
+      result += "\\2c ";
+      continue;
+    }
+    if (codeUnit >= 1 && codeUnit <= 31 || codeUnit === 127 || index === 0 && codeUnit >= 48 && codeUnit <= 57 || index === 1 && codeUnit >= 48 && codeUnit <= 57 && firstCodeUnit === 45) {
+      result += `\\${codeUnit.toString(16)} `;
+      continue;
+    }
+    if (index === 0 && length === 1 && codeUnit === 45) {
+      result += `\\${str.charAt(index)}`;
+      continue;
+    }
+    if (codeUnit >= 128 || codeUnit === 45 || codeUnit === 95 || codeUnit >= 48 && codeUnit <= 57 || codeUnit >= 65 && codeUnit <= 90 || codeUnit >= 97 && codeUnit <= 122) {
+      result += str.charAt(index);
+      continue;
+    }
+    result += `\\${str.charAt(index)}`;
+  }
+  return result;
+}
+var e = escapeSelector;
+
+// src/utils/object.ts
+function entriesToCss(arr) {
+  if (arr == null)
+    return "";
+  return arr.map(([key, value]) => value != null ? `${key}:${value};` : void 0).filter(Boolean).join("");
+}
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+function mergeDeep(original, patch) {
+  const o = original;
+  const p = patch;
+  if (Array.isArray(o) && Array.isArray(p))
+    return [...o, ...p];
+  if (Array.isArray(o))
+    return [...o];
+  const output = __spreadValues({}, o);
+  if (isObject(o) && isObject(p)) {
+    Object.keys(p).forEach((key) => {
+      if (isObject(p[key])) {
+        if (!(key in o))
+          Object.assign(output, { [key]: p[key] });
+        else
+          output[key] = mergeDeep(o[key], p[key]);
+      } else {
+        Object.assign(output, { [key]: p[key] });
+      }
+    });
+  }
+  return output;
+}
+function isStaticRule(rule) {
+  return typeof rule[0] === "string";
+}
+function isStaticShortcut(sc) {
+  return typeof sc[0] === "string";
+}
+
+// src/utils/basic.ts
+function toArray(value = []) {
+  return Array.isArray(value) ? value : [value];
+}
+function uniq(value) {
+  return Array.from(new Set(value));
+}
+function mergeSet(target, append) {
+  append.forEach((i) => target.add(i));
+  return target;
+}
+
+// src/utils/variant.ts
+var variantMatcher = (name) => {
+  const length = name.length + 1;
+  const re = new RegExp(`^${name}[:-]`);
+  return (input) => input.match(re) ? input.slice(length) : void 0;
+};
+
+// src/utils/handlers/handlers.ts
+var handlers_exports = {};
+__export(handlers_exports, {
+  border: () => border,
+  bracket: () => bracket,
+  fraction: () => fraction,
+  number: () => number,
+  percent: () => percent,
+  size: () => size
+});
+var numberWithUnitRE = /^(-?[0-9.]+)([a-z]*)$/i;
+var numberRE = /^(-?[0-9.]+)$/i;
+function size(str) {
+  if (str === "auto" || str === "a")
+    return "auto";
+  const match = str.match(numberWithUnitRE);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  if (unit)
+    return str;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return `${num / 4}rem`;
+}
+function border(str) {
+  const match = str.match(numberWithUnitRE);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  if (unit)
+    return str;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return `${num}px`;
+}
+function number(str) {
+  if (!numberRE.test(str))
+    return;
+  const num = parseFloat(str);
+  if (!Number.isNaN(num))
+    return num;
+}
+function percent(str) {
+  if (str.endsWith("%"))
+    str = str.slice(0, -1);
+  const num = parseFloat(str);
+  if (!Number.isNaN(num))
+    return `${num / 100}`;
+}
+function fraction(str) {
+  const [left, right] = str.split("/");
+  const num = parseFloat(left) / parseFloat(right);
+  if (!Number.isNaN(num))
+    return `${num * 100}%`;
+}
+function bracket(str) {
+  if (str[0] === "[" && str[str.length - 1] === "]")
+    return str.slice(1, -1);
+}
+
+// src/utils/handlers/shorthand.ts
+var handlersNames = Object.keys(handlers_exports);
+var handler = function(str) {
+  var _a;
+  const s = ((_a = this.__options) == null ? void 0 : _a.sequence) || [];
+  this.__options.sequence = [];
+  for (const n of s) {
+    const res = handlers_exports[n](str);
+    if (res)
+      return res;
+  }
+  return void 0;
+};
+function addProcessor(that, name) {
+  if (!that.__options) {
+    that.__options = {
+      sequence: []
+    };
+  }
+  that.__options.sequence.push(name);
+  return that;
+}
+handlersNames.forEach((i) => {
+  Object.defineProperty(handler, i, {
+    enumerable: true,
+    get() {
+      return addProcessor(this, i);
+    }
+  });
+});
+
+// src/utils/colors.ts
+var hexRE = /^#?([\da-f]+)$/i;
+function hex2rgba(hex) {
+  const [, body] = hex.match(hexRE) || [];
+  if (!body)
+    return;
+  switch (body.length) {
+    case 3:
+    case 4:
+      const digits = Array.from(body, (s) => Number.parseInt(s, 16)).map((n) => n << 4 | n);
+      if (body.length === 3)
+        return digits;
+      digits[3] = Math.round(digits[3] / 255 * 100) / 100;
+      return digits;
+    case 6:
+    case 8:
+      const value = Number.parseInt(body, 16);
+      if (body.length === 6)
+        return [value >> 16 & 255, value >> 8 & 255, value & 255];
+      return [value >> 24 & 255, value >> 16 & 255, value >> 8 & 255, Math.round((value & 255) / 255 * 100) / 100];
+  }
+}
+
+// src/utils/playground.ts
+function getMatchedPositions(code, matched) {
+  const result = [];
+  const attributify = [];
+  const plain = new Set();
+  Array.from(matched).forEach((v) => {
+    const match = isAttributifySelector(v);
+    if (!match)
+      plain.add(v);
+    else if (!match[2])
+      plain.add(match[1]);
+    else
+      attributify.push(match);
+  });
+  let start = 0;
+  code.split(/[\s"';<>]/g).forEach((i) => {
+    const end = start + i.length;
+    if (plain.has(i))
+      result.push([start, end]);
+    start = end + 1;
+  });
+  attributify.forEach(([, name, value]) => {
+    const regex = new RegExp(`${escapeRegExp(name)}=(['"])[^\\1]*?${escapeRegExp(value)}[^\\1]*?\\1`, "g");
+    Array.from(code.matchAll(regex)).forEach((match) => {
+      const start2 = match.index + match[0].indexOf(value);
+      const end = start2 + value.length;
+      result.push([start2, end]);
+    });
+  });
+  return result;
+}
+
+// src/utils/regex.ts
+var attributifyRE = /^\[(.+?)~?="(.*)"\]$/;
+var validateFilterRE = /[a-z]/;
+function isAttributifySelector(selector) {
+  return selector.match(attributifyRE);
+}
+function isValidSelector(selector = "") {
+  return validateFilterRE.test(selector);
+}
+
+// src/utils/map.ts
+var TwoKeyMap = class {
+  constructor() {
+    this._map = new Map();
+  }
+  get(key1, key2) {
+    const m2 = this._map.get(key1);
+    if (m2)
+      return m2.get(key2);
+  }
+  getFallback(key1, key2, fallback) {
+    let m2 = this._map.get(key1);
+    if (!m2) {
+      m2 = new Map();
+      this._map.set(key1, m2);
+    }
+    if (!m2.has(key2))
+      m2.set(key2, fallback);
+    return m2.get(key2);
+  }
+  set(key1, key2, value) {
+    let m2 = this._map.get(key1);
+    if (!m2) {
+      m2 = new Map();
+      this._map.set(key1, m2);
+    }
+    m2.set(key2, value);
+    return this;
+  }
+  has(key1, key2) {
+    var _a;
+    return (_a = this._map.get(key1)) == null ? void 0 : _a.has(key2);
+  }
+  delete(key1, key2) {
+    var _a;
+    return ((_a = this._map.get(key1)) == null ? void 0 : _a.delete(key2)) || false;
+  }
+  deleteTop(key1) {
+    return this._map.delete(key1);
+  }
+  map(fn) {
+    return Array.from(this._map.entries()).flatMap(([k1, m2]) => Array.from(m2.entries()).map(([k2, v]) => {
+      return fn(v, k1, k2);
+    }));
+  }
+};
+var BetterMap = class extends Map {
+  map(mapFn) {
+    const result = [];
+    this.forEach((v, k) => {
+      result.push(mapFn(v, k));
+    });
+    return result;
+  }
+};
+
+// src/extractors/split.ts
+var extractorSplit = (code) => new Set(code.split(/[\s'"`;>=]/g).filter(isValidSelector));
+
+// src/config.ts
+function resolveShortcuts(shortcuts) {
+  return toArray(shortcuts).flatMap((s) => {
+    if (Array.isArray(s))
+      return [s];
+    return Object.entries(s);
+  });
+}
+function resolveConfig(userConfig = {}, defaults = {}) {
+  const config = Object.assign({}, defaults, userConfig);
+  const rawPresets = config.presets || [];
+  const sortedPresets = [
+    ...rawPresets.filter((p) => p.enforce === "pre"),
+    ...rawPresets.filter((p) => !p.enforce),
+    ...rawPresets.filter((p) => p.enforce === "post")
+  ];
+  function mergePresets(key) {
+    return uniq([
+      ...sortedPresets.flatMap((p) => toArray(p[key] || [])),
+      ...toArray(config[key] || [])
+    ]);
+  }
+  const extractors = mergePresets("extractors");
+  if (!extractors.length)
+    extractors.push(extractorSplit);
+  const rules = mergePresets("rules");
+  const rulesStaticMap = {};
+  const rulesSize = rules.length;
+  rules.forEach((rule, i) => {
+    if (isStaticRule(rule)) {
+      rulesStaticMap[rule[0]] = [i, rule[1]];
+      delete rules[i];
+    }
+  });
+  const theme = [
+    ...sortedPresets.map((p) => p.theme || {}),
+    config.theme || {}
+  ].reduce((a, p) => mergeDeep(a, p), {});
+  return __spreadProps(__spreadValues({
+    mergeSelectors: true,
+    warnExcluded: true,
+    excluded: []
+  }, config), {
+    theme,
+    rulesSize,
+    rulesDynamic: rules,
+    rulesStaticMap,
+    variants: mergePresets("variants"),
+    shortcuts: resolveShortcuts(mergePresets("shortcuts")),
+    extractors
+  });
+}
+
+// src/generator/utils.ts
+var reScopePlaceholder = / \$\$ /;
+var hasScopePlaceholder = (css) => css.match(reScopePlaceholder);
+function applyScope(css, scope) {
+  if (hasScopePlaceholder(css))
+    return css.replace(reScopePlaceholder, scope ? ` ${scope} ` : " ");
+  else
+    return scope ? `${scope} ${css}` : css;
+}
+function toEscapedSelector(raw) {
+  if (raw.startsWith("["))
+    return raw.replace(/^\[(.+?)(~?=)"(.*)"\]$/, (_, n, s, i) => `[${escapeSelector(n)}${s}"${escapeSelector(i)}"]`);
+  else
+    return `.${escapeSelector(raw)}`;
+}
+function normalizeEntries(obj) {
+  return !Array.isArray(obj) ? Object.entries(obj) : obj;
+}
+
+// src/generator/index.ts
+var UnoGenerator = class {
+  constructor(userConfig = {}, defaults = {}) {
+    this.userConfig = userConfig;
+    this.defaults = defaults;
+    this._cache = new Map();
+    this.excluded = new Set();
+    this.config = resolveConfig(userConfig, defaults);
+  }
+  setConfig(userConfig, defaults) {
+    if (!userConfig)
+      return;
+    if (defaults)
+      this.defaults = defaults;
+    this.userConfig = userConfig;
+    this.config = resolveConfig(userConfig, this.defaults);
+    this.excluded = new Set();
+    this._cache = new Map();
+  }
+  async applyExtractors(code, id, set = new Set()) {
+    await Promise.all(this.config.extractors.map(async (i) => {
+      const result = await i(code, id);
+      result == null ? void 0 : result.forEach((t) => set.add(t));
+    }));
+    return set;
+  }
+  async generate(input, id, scope) {
+    const tokens = typeof input === "string" ? await this.applyExtractors(input, id) : input;
+    const matched = new Set();
+    const sheet = new Map();
+    const hit = (raw, payload) => {
+      this._cache.set(raw, payload);
+      matched.add(raw);
+      for (const item of payload) {
+        const query = item[3] || "";
+        if (!sheet.has(query))
+          sheet.set(query, []);
+        sheet.get(query).push(item);
+      }
+    };
+    await Promise.all(Array.from(tokens).map(async (raw) => {
+      if (matched.has(raw) || this.excluded.has(raw))
+        return;
+      if (this._cache.has(raw)) {
+        const r = this._cache.get(raw);
+        if (r)
+          hit(raw, r);
+        return;
+      }
+      if (this.isExcluded(raw)) {
+        this.excluded.add(raw);
+        this._cache.set(raw, null);
+        return;
+      }
+      const applied = this.matchVariants(raw);
+      if (this.isExcluded(applied[1])) {
+        this.excluded.add(raw);
+        this._cache.set(raw, null);
+        return;
+      }
+      const expanded = this.expandShortcut(applied[1]);
+      if (expanded) {
+        const utils = await this.stringifyShortcuts(applied, expanded);
+        if (utils.length) {
+          hit(raw, utils);
+          return;
+        }
+      } else {
+        const util = this.stringifyUtil(await this.parseUtil(applied));
+        if (util) {
+          hit(raw, [util]);
+          return;
+        }
+      }
+      this._cache.set(raw, null);
+    }));
+    const css = Array.from(sheet).map(([query, items]) => {
+      const size2 = items.length;
+      const sorted = items.sort((a, b) => a[0] - b[0] || a[1].localeCompare(b[1])).map((a) => [applyScope(a[1], scope), a[2]]);
+      const rules = sorted.map(([selector, body], idx) => {
+        if (this.config.mergeSelectors) {
+          for (let i = size2 - 1; i > idx; i--) {
+            const current = sorted[i];
+            if (current[1] === body) {
+              current[0] = `${selector},${current[0]}`;
+              return null;
+            }
+          }
+        }
+        return `${selector}{${body}}`;
+      }).filter(Boolean).join("\n");
+      return query ? `${query}{
+${rules}
+}` : rules;
+    }).join("\n");
+    return {
+      css,
+      matched
+    };
+  }
+  matchVariants(raw) {
+    const variants = [];
+    let processed = raw;
+    let applied = false;
+    while (true) {
+      applied = false;
+      for (const v of this.config.variants) {
+        const result = v.match(processed, this.config.theme);
+        if (result && result !== processed) {
+          processed = result;
+          variants.push(v);
+          applied = true;
+          break;
+        }
+      }
+      if (!applied)
+        break;
+    }
+    return [raw, processed, variants];
+  }
+  applyVariants(parsed, variants = parsed[3], raw = parsed[1]) {
+    const theme = this.config.theme;
+    const selector = variants.reduce((p, v) => {
+      var _a;
+      return ((_a = v.selector) == null ? void 0 : _a.call(v, p, theme)) || p;
+    }, toEscapedSelector(raw));
+    const mediaQuery = variants.reduce((p, v) => {
+      var _a;
+      return ((_a = v.mediaQuery) == null ? void 0 : _a.call(v, parsed[1], theme)) || p;
+    }, void 0);
+    const entries = variants.reduce((p, v) => {
+      var _a;
+      return ((_a = v.rewrite) == null ? void 0 : _a.call(v, p, theme)) || p;
+    }, parsed[2]);
+    return [
+      selector,
+      entries,
+      mediaQuery
+    ];
+  }
+  async parseUtil(input) {
+    const { theme, rulesStaticMap, rulesDynamic, rulesSize } = this.config;
+    const [raw, processed, variants] = typeof input === "string" ? this.matchVariants(input) : input;
+    const staticMatch = rulesStaticMap[processed];
+    if (staticMatch == null ? void 0 : staticMatch[1])
+      return [staticMatch[0], raw, normalizeEntries(staticMatch[1]), variants];
+    for (let i = rulesSize; i >= 0; i--) {
+      const rule = rulesDynamic[i];
+      if (!rule)
+        continue;
+      const [matcher, handler2] = rule;
+      const match = processed.match(matcher);
+      if (!match)
+        continue;
+      const obj = await handler2(match, theme);
+      if (obj)
+        return [i, raw, normalizeEntries(obj), variants];
+    }
+  }
+  stringifyUtil(parsed) {
+    if (!parsed)
+      return;
+    const [selector, entries, mediaQuery] = this.applyVariants(parsed);
+    const body = entriesToCss(entries);
+    if (!body)
+      return;
+    return [parsed[0], selector, body, mediaQuery];
+  }
+  expandShortcut(processed) {
+    let result;
+    for (const s of this.config.shortcuts) {
+      if (isStaticShortcut(s)) {
+        if (s[0] === processed)
+          result = s[1];
+      } else {
+        const match = processed.match(s[0]);
+        if (match)
+          result = s[1](match);
+        if (result)
+          break;
+      }
+    }
+    if (!result)
+      return;
+    if (typeof result === "string")
+      result = result.split(/ /g);
+    return result;
+  }
+  async stringifyShortcuts(parent, expanded) {
+    const selectorMap = new TwoKeyMap();
+    const parsed = (await Promise.all(expanded.map((i) => this.parseUtil(i)))).filter(Boolean).sort((a, b) => a[0] - b[0]);
+    const [raw, , parentVariants] = parent;
+    for (const item of parsed) {
+      const [selector, entries, mediaQuery] = this.applyVariants(item, [...item[3], ...parentVariants], raw);
+      const mapItem = selectorMap.getFallback(selector, mediaQuery, [[], item[0]]);
+      mapItem[0].push(...entries);
+      if (item[0] > mapItem[1])
+        mapItem[1] = item[0];
+    }
+    return selectorMap.map(([entries, index], selector, mediaQuery) => {
+      const body = entriesToCss(entries);
+      if (!body)
+        return void 0;
+      return [index, selector, body, mediaQuery];
+    }).filter(Boolean);
+  }
+  isExcluded(raw) {
+    return this.config.excluded.some((e2) => typeof e2 === "string" ? e2 === raw : e2.test(raw));
+  }
+};
+function createGenerator(config, defaults) {
+  return new UnoGenerator(config, defaults);
+}
+export {
+  BetterMap,
+  TwoKeyMap,
+  UnoGenerator,
+  attributifyRE,
+  border,
+  bracket,
+  createGenerator,
+  defineConfig,
+  e,
+  entriesToCss,
+  escapeRegExp,
+  escapeSelector,
+  extractorSplit,
+  fraction,
+  getMatchedPositions,
+  handler,
+  handlersNames,
+  hex2rgba,
+  isAttributifySelector,
+  isObject,
+  isStaticRule,
+  isStaticShortcut,
+  isValidSelector,
+  mergeDeep,
+  mergeSet,
+  number,
+  percent,
+  size,
+  toArray,
+  uniq,
+  validateFilterRE,
+  variantMatcher
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "@unocss/core",
+	"version": "0.1.0-beta.2",
+	"description": "",
+	"keywords": [],
+	"homepage": "https://github.com/antfu/unocss#readme",
+	"bugs": {
+		"url": "https://github.com/antfu/unocss/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/antfu/unocss.git"
+	},
+	"funding": "https://github.com/sponsors/antfu",
+	"license": "MIT",
+	"author": "Anthony Fu <anthonyfu117@hotmail.com>",
+	"sideEffects": false,
+	"exports": {
+		".": {
+			"require": "./dist/index.js",
+			"import": "./dist/index.mjs"
+		}
+	},
+	"main": "dist/index.js",
+	"module": "dist/index.mjs",
+	"types": "dist/index.d.ts",
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsup",
+		"dev": "tsup --watch src"
+	}
+}