@symbo.ls/scratch 3.4.4 → 3.4.6

package/dist/cjs/transforms/index.js

@@ -0,0 +1,219 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transforms_exports = {};
+__export(transforms_exports, {
+  resolveColorsInGradient: () => resolveColorsInGradient,
+  splitTransition: () => splitTransition,
+  transformBackgroundImage: () => transformBackgroundImage,
+  transformBorder: () => transformBorder,
+  transformBorderRadius: () => transformBorderRadius,
+  transformBoxShadow: () => transformBoxShadow,
+  transformDuration: () => transformDuration,
+  transformShadow: () => transformShadow,
+  transformSize: () => transformSize,
+  transformSizeRatio: () => transformSizeRatio,
+  transformTextStroke: () => transformTextStroke,
+  transformTransition: () => transformTransition,
+  transfromGap: () => transfromGap
+});
+module.exports = __toCommonJS(transforms_exports);
+var import_utils = require("@domql/utils");
+var import_factory = require("../factory");
+var import_system = require("../system");
+var import_utils2 = require("../utils");
+const BORDER_STYLES = /* @__PURE__ */ new Set([
+  "none",
+  "hidden",
+  "dotted",
+  "dashed",
+  "solid",
+  "double",
+  "groove",
+  "ridge",
+  "inset",
+  "outset",
+  "initial"
+]);
+const GRADIENT_KEYWORDS = /* @__PURE__ */ new Set([
+  "to",
+  "top",
+  "bottom",
+  "left",
+  "right",
+  "center",
+  "at",
+  "circle",
+  "ellipse",
+  "closest-side",
+  "farthest-side",
+  "closest-corner",
+  "farthest-corner"
+]);
+const isBorderStyle = (str) => BORDER_STYLES.has(str);
+const transformBorder = (border) => {
+  const str = border + "";
+  if (import_utils2.CSS_NATIVE_COLOR_REGEX.test(str)) return str;
+  const trimmed = str.trim();
+  if (trimmed === "none" || trimmed === "0" || trimmed === "initial" || trimmed === "inherit" || trimmed === "unset") return str;
+  const tokens = str.split(/\s+/);
+  return tokens.map((v) => {
+    v = v.trim();
+    if (!v) return "";
+    if ((0, import_utils2.isCSSVar)(v)) return `var(${v})`;
+    if (isBorderStyle(v)) return v;
+    if (/^\d/.test(v) || v === "0") return v;
+    const color = (0, import_system.getColor)(v);
+    if ((0, import_utils2.isResolvedColor)(color)) return color;
+    const spacing = (0, import_system.getSpacingByKey)(v, "border");
+    if (spacing && spacing.border) return spacing.border;
+    return v;
+  }).join(" ");
+};
+const transformTextStroke = (stroke) => {
+  if (import_utils2.CSS_NATIVE_COLOR_REGEX.test(stroke)) return stroke;
+  return stroke.split(/\s+/).map((v) => {
+    v = v.trim();
+    if (!v) return "";
+    if ((0, import_utils2.isCSSVar)(v)) return `var(${v})`;
+    if (/^\d/.test(v) || v.includes("px") || v === "0") return v;
+    const color = (0, import_system.getColor)(v);
+    if ((0, import_utils2.isResolvedColor)(color)) return color;
+    return v;
+  }).join(" ");
+};
+const transformShadow = (sh, globalTheme) => (0, import_system.getShadow)(sh, globalTheme);
+const transformBoxShadow = (shadows, globalTheme) => {
+  if (import_utils2.CSS_NATIVE_COLOR_REGEX.test(shadows)) return shadows;
+  return (0, import_utils2.splitTopLevelCommas)(shadows).map((shadow) => {
+    shadow = shadow.trim();
+    if (!shadow) return "";
+    return shadow.split(/\s+/).map((v) => {
+      v = v.trim();
+      if (!v) return "";
+      if ((0, import_utils2.isCSSVar)(v)) return `var(${v})`;
+      if (v === "inset" || v === "none") return v;
+      const color = (0, import_system.getColor)(v);
+      if ((0, import_utils2.isResolvedColor)(color)) {
+        const mediaColor = (0, import_system.getMediaColor)(v, globalTheme);
+        if ((0, import_utils.isObject)(mediaColor))
+          return Object.values(mediaColor).filter(
+            (c) => c.includes(": " + globalTheme)
+          )[0];
+        return mediaColor;
+      }
+      if (/^\d/.test(v) || v === "0" || v.includes("px") || v.slice(-2) === "em") return v;
+      const spacing = (0, import_system.getSpacingByKey)(v, "shadow");
+      if (spacing && spacing.shadow) return spacing.shadow;
+      return v;
+    }).join(" ");
+  }).join(", ");
+};
+const resolveColorsInGradient = (gradient, globalTheme) => {
+  const parenStart = gradient.indexOf("(");
+  if (parenStart === -1) return gradient;
+  const prefix = gradient.slice(0, parenStart + 1);
+  const inner = gradient.slice(parenStart + 1, gradient.lastIndexOf(")"));
+  const suffix = ")";
+  const segments = (0, import_utils2.splitTopLevelCommas)(inner);
+  const resolved = segments.map((segment) => {
+    segment = segment.trim();
+    const tokens = segment.split(/\s+/);
+    return tokens.map((token) => {
+      if (!token) return token;
+      if (/^\d/.test(token) || token === "0") return token;
+      if (GRADIENT_KEYWORDS.has(token)) return token;
+      if (token === "transparent") return token;
+      if (import_utils2.CSS_NATIVE_COLOR_REGEX.test(token)) return token;
+      const color = (0, import_system.getColor)(token);
+      if ((0, import_utils2.isResolvedColor)(color)) return color;
+      return token;
+    }).join(" ");
+  });
+  return prefix + resolved.join(", ") + suffix;
+};
+const transformBackgroundImage = (backgroundImage, globalTheme) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  return backgroundImage.split(", ").map((v) => {
+    if ((0, import_utils2.isCSSVar)(v)) return `var(${v})`;
+    if (v.includes("url")) return v;
+    if (v.includes("gradient")) return resolveColorsInGradient(v, globalTheme);
+    else if (CONFIG.GRADIENT[backgroundImage]) {
+      return {
+        backgroundImage: (0, import_system.getMediaColor)(
+          backgroundImage,
+          globalTheme || CONFIG.globalTheme
+        )
+      };
+    } else if (v.includes("/") || v.startsWith("http") || v.includes(".") && !(0, import_utils2.parseColorToken)(v))
+      return `url(${v})`;
+    return v;
+  }).join(" ");
+};
+const transfromGap = (gap) => (0, import_utils.isString)(gap) && gap.split(" ").map((v) => (0, import_system.getSpacingByKey)(v, "gap").gap).join(" ");
+const transformTransition = (transition) => {
+  const arr = transition.split(" ");
+  if (!arr.length) return transition;
+  return arr.map((v) => {
+    if ((0, import_utils2.isCSSVar)(v)) return `var(${v})`;
+    if (v.length < 3 || v.includes("ms")) {
+      const mapWithSequence = (0, import_system.getTimingByKey)(v);
+      return mapWithSequence.timing || v;
+    }
+    if ((0, import_system.getTimingFunction)(v)) return (0, import_system.getTimingFunction)(v);
+    return v;
+  }).join(" ");
+};
+const transformDuration = (duration, props, propertyName) => {
+  if (!(0, import_utils.isString)(duration)) return;
+  return duration.split(",").map((v) => (0, import_system.getTimingByKey)(v).timing || v).join(",");
+};
+const splitTransition = (transition) => {
+  const arr = transition.split(",");
+  if (!arr.length) return;
+  return arr.map(transformTransition).join(",");
+};
+function transformSize(propertyName, val, props = {}, opts = {}) {
+  let value = import_utils.exec.call(this, val || props[propertyName]);
+  if (value === void 0 || value === null) return;
+  let fnPrefix;
+  if ((0, import_utils.isString)(value)) {
+    if (value.includes("(")) {
+      const fnArr = (0, import_utils2.getFnPrefixAndValue)(value);
+      fnPrefix = fnArr[0];
+      value = fnArr[1];
+    }
+    const shouldScaleBoxSize = props.scaleBoxSize;
+    const isBoxSize = (0, import_system.checkIfBoxSize)(propertyName);
+    if (!shouldScaleBoxSize && isBoxSize) {
+      value = (0, import_system.splitSpacedValue)(value);
+    }
+  }
+  return opts.ratio ? (0, import_system.getSpacingBasedOnRatio)(props, propertyName, value, fnPrefix) : (0, import_system.getSpacingByKey)(value, propertyName, void 0, fnPrefix);
+}
+const transformSizeRatio = (propertyName, val = null, props) => {
+  return transformSize(propertyName, val, props, {
+    ratio: true
+  });
+};
+const transformBorderRadius = (radius, props, propertyName) => {
+  if (!(0, import_utils.isString)(radius)) return;
+  return {
+    borderRadius: radius.split(" ").map((v, k) => (0, import_system.getSpacingBasedOnRatio)(props, propertyName, v)[propertyName]).join(" ")
+  };
+};

package/dist/cjs/utils/color.js

@@ -0,0 +1,206 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var color_exports = {};
+__export(color_exports, {
+  CSS_NATIVE_COLOR_REGEX: () => CSS_NATIVE_COLOR_REGEX,
+  changeLightness: () => changeLightness,
+  colorStringToRgbaArray: () => colorStringToRgbaArray,
+  getColorShade: () => getColorShade,
+  getRgbTone: () => getRgbTone,
+  hexToRgb: () => hexToRgb,
+  hexToRgbArray: () => hexToRgbArray,
+  hexToRgba: () => hexToRgba,
+  hslToRgb: () => hslToRgb,
+  isCSSVar: () => isCSSVar,
+  isResolvedColor: () => isResolvedColor,
+  mixTwoColors: () => mixTwoColors,
+  mixTwoRgb: () => mixTwoRgb,
+  mixTwoRgba: () => mixTwoRgba,
+  opacify: () => opacify,
+  parseColorToken: () => parseColorToken,
+  rgbArrayToHex: () => rgbArrayToHex,
+  rgbToHSL: () => rgbToHSL,
+  rgbToHex: () => rgbToHex,
+  splitTopLevelCommas: () => splitTopLevelCommas
+});
+module.exports = __toCommonJS(color_exports);
+var import_utils = require("@domql/utils");
+const colorStringToRgbaArray = (color) => {
+  if (color === "") return [0, 0, 0, 0];
+  if (color.toLowerCase() === "transparent") return [0, 0, 0, 0];
+  if (color[0] === "#") {
+    if (color.length < 7) {
+      color = "#" + color[1] + color[1] + color[2] + color[2] + color[3] + color[3] + (color.length > 4 ? color[4] + color[4] : "");
+    }
+    return [
+      parseInt(color.substr(1, 2), 16),
+      parseInt(color.substr(3, 2), 16),
+      parseInt(color.substr(5, 2), 16),
+      color.length > 7 ? parseInt(color.substr(7, 2), 16) / 255 : 1
+    ];
+  }
+  if (color.indexOf("rgb") === -1) {
+    if (import_utils.document && import_utils.window) {
+      const elem = import_utils.document.body.appendChild(import_utils.document.createElement("fictum"));
+      const flag = "rgb(1, 2, 3)";
+      elem.style.color = flag;
+      if (elem.style.color !== flag) {
+        import_utils.document.body.removeChild(elem);
+        return;
+      }
+      elem.style.color = color;
+      if (elem.style.color === flag || elem.style.color === "") {
+        import_utils.document.body.removeChild(elem);
+        return [0, 0, 0, 0];
+      }
+      color = import_utils.window.getComputedStyle(elem).color;
+      import_utils.document.body.removeChild(elem);
+    }
+  }
+  if (color.indexOf("rgb") === 0) {
+    if (color.indexOf("rgba") === -1) color = `${color}, 1`;
+    return color.match(/[\.\d]+/g).map((a) => +a);
+  }
+  return [0, 0, 0, 0];
+};
+const mixTwoColors = (colorA, colorB, range = 0.5) => {
+  colorA = colorStringToRgbaArray(colorA);
+  colorB = colorStringToRgbaArray(colorB);
+  return mixTwoRgba(colorA, colorB, range);
+};
+const hexToRgb = (hex, alpha = 1) => {
+  const [r, g, b] = hex.match(/\w\w/g).map((x) => parseInt(x, 16));
+  return `rgb(${r},${g},${b})`;
+};
+const hexToRgbArray = (hex, alpha = 1) => {
+  const [r, g, b] = hex.match(/\w\w/g).map((x) => parseInt(x, 16));
+  return [r, g, b];
+};
+const rgbToHex = (r, g, b) => {
+  return "#" + (1 << 24 | r << 16 | g << 8 | b).toString(16).slice(1);
+};
+const rgbArrayToHex = ([r, g, b]) => {
+  return ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+};
+const hexToRgba = (hex, alpha = 1) => {
+  const [r, g, b] = hex.match(/\w\w/g).map((x) => parseInt(x, 16));
+  return `rgba(${r},${g},${b},${alpha})`;
+};
+const mixTwoRgb = (colorA, colorB, range = 0.5) => {
+  const arr = [];
+  for (let i = 0; i < 3; i++) {
+    arr[i] = ~~(colorA[i] + (colorB[i] - colorA[i]) * range);
+  }
+  return `rgb(${arr})`;
+};
+const changeLightness = (delta, hsl) => {
+  const [hue, saturation, lightness] = hsl;
+  const newLightness = Math.max(0, Math.min(100, lightness + parseFloat(delta)));
+  return [hue, saturation, newLightness];
+};
+const rgbToHSL = (r, g, b) => {
+  const a = Math.max(r, g, b);
+  const n = a - Math.min(r, g, b);
+  const f = 1 - Math.abs(a + a - n - 1);
+  const h = n && (a == r ? (g - b) / n : a == g ? 2 + (b - r) / n : 4 + (r - g) / n);
+  return [60 * (h < 0 ? h + 6 : h), f ? n / f : 0, (a + a - n) / 2];
+};
+const hslToRgb = (h, s, l, a = s * Math.min(l, 1 - l), f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1)) => [f(0), f(8), f(4)];
+const getColorShade = (col, amt) => {
+  const num = parseInt(col, 16);
+  let r = (num >> 16) + amt;
+  if (r > 255) r = 255;
+  else if (r < 0) r = 0;
+  let b = (num >> 8 & 255) + amt;
+  if (b > 255) b = 255;
+  else if (b < 0) b = 0;
+  let g = (num & 255) + amt;
+  if (g > 255) g = 255;
+  else if (g < 0) g = 0;
+  return ((g | b << 8 | r << 16) + 16777216).toString(16).slice(1);
+};
+const mixTwoRgba = (colorA, colorB, range = 0.5) => {
+  const arr = [];
+  for (let i = 0; i < 4; i++) {
+    const round = i === 3 ? (x) => x : Math.round;
+    arr[i] = round(colorA[i] + (colorB[i] - colorA[i]) * range);
+  }
+  return `rgba(${arr})`;
+};
+const opacify = (color, opacity) => {
+  const arr = colorStringToRgbaArray(color);
+  if (!arr) {
+    if ((0, import_utils.isNotProduction)()) console.warn(color + " color is not rgba");
+    return;
+  }
+  arr[3] = opacity;
+  return `rgba(${arr})`;
+};
+const isCSSVar = (v) => v.charCodeAt(0) === 45 && v.charCodeAt(1) === 45;
+const CSS_NATIVE_COLOR_REGEX = /(?:rgba?\(|hsla?\(|#[0-9a-fA-F]{3,8}\b)/;
+const COLOR_TOKEN_REGEX = /^([a-zA-Z]\w*)(?:\.(\d+))?(?:([+-]\d+|=\d+))?$/;
+const parseColorToken = (value) => {
+  if (!(0, import_utils.isString)(value)) return null;
+  if (CSS_NATIVE_COLOR_REGEX.test(value)) return { passthrough: value };
+  if (isCSSVar(value)) return { cssVar: value };
+  const match = value.match(COLOR_TOKEN_REGEX);
+  if (!match) return null;
+  const [, name, alphaDigits, rawTone] = match;
+  const alpha = alphaDigits !== void 0 ? `0.${alphaDigits}` : void 0;
+  const tone = rawTone && rawTone[0] === "=" ? rawTone.slice(1) : rawTone;
+  return { name, alpha, tone };
+};
+const isResolvedColor = (result) => {
+  return (0, import_utils.isString)(result) && (result.includes("rgb") || result.includes("var(") || result.includes("#"));
+};
+const splitTopLevelCommas = (value) => {
+  const result = [];
+  let current = "";
+  let depth = 0;
+  for (const char of value) {
+    if (char === "(") depth += 1;
+    else if (char === ")" && depth > 0) depth -= 1;
+    if (char === "," && depth === 0) {
+      result.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.length || !result.length) result.push(current);
+  return result;
+};
+const getRgbTone = (rgb, tone) => {
+  if ((0, import_utils.isString)(rgb) && rgb.includes("rgb"))
+    rgb = colorStringToRgbaArray(rgb).join(", ");
+  if ((0, import_utils.isString)(rgb)) rgb = rgb.split(",").map((v) => parseFloat(v.trim()));
+  if ((0, import_utils.isNumber)(tone)) tone += "";
+  const toHex = rgbArrayToHex(rgb);
+  const abs = tone.slice(0, 1);
+  if (abs === "-" || abs === "+") {
+    const colorShade = getColorShade(toHex, parseFloat(tone));
+    return hexToRgbArray(colorShade).join(", ");
+  } else {
+    const [r, g, b] = rgb;
+    const hsl = rgbToHSL(r, g, b);
+    const [h, s, l] = hsl;
+    const newRgb = hslToRgb(h, s, parseFloat(tone) / 100 * 255);
+    return newRgb;
+  }
+};

package/dist/cjs/utils/font.js

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var font_exports = {};
+__export(font_exports, {
+  getDefaultOrFirstKey: () => getDefaultOrFirstKey,
+  getFontFace: () => getFontFace,
+  getFontFaceEach: () => getFontFaceEach,
+  getFontFaceEachString: () => getFontFaceEachString,
+  getFontFaceString: () => getFontFaceString,
+  getFontFormat: () => getFontFormat,
+  isGoogleFontsUrl: () => isGoogleFontsUrl,
+  setCustomFont: () => setCustomFont,
+  setCustomFontMedia: () => setCustomFontMedia,
+  setFontImport: () => setFontImport,
+  setInCustomFontMedia: () => setInCustomFontMedia
+});
+module.exports = __toCommonJS(font_exports);
+const getDefaultOrFirstKey = (LIBRARY, key) => {
+  if (LIBRARY[key]) return LIBRARY[key].value;
+  if (LIBRARY.default) return LIBRARY[LIBRARY.default].value;
+  const hasValue = Object.keys(LIBRARY)[0];
+  return hasValue && LIBRARY[hasValue] && LIBRARY[hasValue].value;
+};
+const getFontFormat = (url) => {
+  const ext = url.split(/[#?]/)[0].split(".").pop().trim();
+  if (["woff2", "woff", "ttf", "otf", "eot"].includes(ext)) return ext;
+  return null;
+};
+const isGoogleFontsUrl = (url) => url && (url.includes("fonts.googleapis.com") || url.includes("fonts.gstatic.com"));
+const setFontImport = (url) => `@import url('${url}');`;
+const setInCustomFontMedia = (str) => `@font-face { ${str} }`;
+const setCustomFont = (name, url, weight, options = {}) => {
+  const format = getFontFormat(url);
+  const formatStr = format ? ` format('${format}')` : "";
+  return `
+  font-family: '${name}';
+  font-style: normal;${weight ? `
+  font-weight: ${weight};` : ""}${options.fontStretch ? `
+  font-stretch: ${options.fontStretch};` : ""}${options.fontDisplay ? `
+  font-display: ${options.fontDisplay};` : ""}
+  src: url('${url}')${formatStr};`;
+};
+const setCustomFontMedia = (name, url, weight, options) => `@font-face {${setCustomFont(name, url, weight, options)}
+}`;
+const getFontFaceEach = (name, weights) => {
+  const keys = Object.keys(weights);
+  return keys.map((key) => {
+    const { url, fontWeight } = weights[key];
+    return setCustomFont(name, url, fontWeight);
+  });
+};
+const getFontFace = (LIBRARY) => {
+  const keys = Object.keys(LIBRARY);
+  return keys.map((key) => getFontFaceEach(key, LIBRARY[key].value));
+};
+const getFontFaceEachString = (name, weights) => {
+  if (weights && weights.isVariable) {
+    if (isGoogleFontsUrl(weights.url)) {
+      return setFontImport(weights.url);
+    }
+    return setCustomFontMedia(name, weights.url, weights.fontWeight, {
+      fontStretch: weights.fontStretch,
+      fontDisplay: weights.fontDisplay || "swap"
+    });
+  }
+  const isArr = weights[0];
+  if (isArr) return getFontFaceEach(name, weights).map(setInCustomFontMedia);
+  return setCustomFontMedia(name, weights.url);
+};
+const getFontFaceString = (LIBRARY) => {
+  const keys = Object.keys(LIBRARY);
+  return keys.map((key) => getFontFaceEachString(key, LIBRARY[key].value));
+};

package/dist/cjs/utils/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./unit.js"), module.exports);
+__reExport(utils_exports, require("./color.js"), module.exports);
+__reExport(utils_exports, require("./theme.js"), module.exports);
+__reExport(utils_exports, require("./font.js"), module.exports);
+__reExport(utils_exports, require("./sequence.js"), module.exports);
+__reExport(utils_exports, require("./var.js"), module.exports);
+__reExport(utils_exports, require("./sprite.js"), module.exports);