@symbo.ls/scratch 2.10.149 → 2.10.156

package/dist/cjs/index.js

@@ -0,0 +1,21 @@
+"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 src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./factory.js"), module.exports);
+__reExport(src_exports, require("./utils"), module.exports);
+__reExport(src_exports, require("./set.js"), module.exports);
+__reExport(src_exports, require("./defaultConfig"), module.exports);

package/dist/cjs/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "main": "index.js"
+}

package/dist/cjs/set.js

@@ -0,0 +1,121 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var set_exports = {};
+__export(set_exports, {
+  VALUE_TRANSFORMERS: () => VALUE_TRANSFORMERS,
+  set: () => set,
+  setEach: () => setEach,
+  setValue: () => setValue
+});
+module.exports = __toCommonJS(set_exports);
+var import_factory = require("./factory.js");
+var import_system = require("./system");
+var import_utils = require("./utils");
+__reExport(set_exports, require("./system"), module.exports);
+const ENV = "development";
+const setCases = (val, key) => {
+  if ((0, import_utils.isFunction)(val))
+    return val();
+  return val;
+};
+const setSameValue = (val, key) => val;
+const VALUE_TRANSFORMERS = {
+  color: import_system.setColor,
+  gradient: import_system.setGradient,
+  font: import_system.setFont,
+  font_family: import_system.setFontFamily,
+  theme: import_system.setTheme,
+  icons: import_system.setIcon,
+  svg: import_system.setSVG,
+  svg_data: setSameValue,
+  typography: setSameValue,
+  cases: setCases,
+  spacing: setSameValue,
+  media: setSameValue,
+  timing: setSameValue,
+  reset: setSameValue,
+  unit: setSameValue,
+  animation: setSameValue
+};
+const setValue = (FACTORY_NAME, value, key) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  const factoryName = FACTORY_NAME.toLowerCase();
+  const FACTORY2 = CONFIG[FACTORY_NAME];
+  if (VALUE_TRANSFORMERS[factoryName]) {
+    const result = VALUE_TRANSFORMERS[factoryName](value, key);
+    FACTORY2[key] = result;
+    return FACTORY2;
+  }
+  if (CONFIG.verbose)
+    console.warn("Can not find", factoryName, "method in scratch");
+};
+const setEach = (factoryName, props) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  const FACTORY_NAME = factoryName.toUpperCase();
+  const keys = Object.keys(props);
+  keys.map((key) => setValue(FACTORY_NAME, props[key], key));
+  return CONFIG[FACTORY_NAME];
+};
+const SET_OPTIONS = {};
+const set = (recivedConfig, options = SET_OPTIONS) => {
+  let CONFIG = (0, import_factory.getActiveConfig)();
+  const {
+    version,
+    verbose,
+    useVariable,
+    useReset,
+    useSvgSprite,
+    useFontImport,
+    useIconSprite,
+    globalTheme,
+    useDocumentTheme,
+    ...config
+  } = recivedConfig;
+  if (options.newConfig) {
+    import_factory.FACTORY["active"] = options.newConfig;
+    CONFIG = (0, import_factory.getActiveConfig)(options.newConfig);
+  }
+  if (verbose !== void 0)
+    CONFIG.verbose = verbose;
+  if (useVariable !== void 0)
+    CONFIG.useVariable = useVariable;
+  if (useReset !== void 0)
+    CONFIG.useReset = useReset;
+  if (useFontImport !== void 0)
+    CONFIG.useFontImport = useFontImport;
+  if (useSvgSprite !== void 0)
+    CONFIG.useSvgSprite = useSvgSprite;
+  if (useIconSprite !== void 0)
+    CONFIG.useIconSprite = useIconSprite;
+  if (useDocumentTheme !== void 0)
+    CONFIG.useDocumentTheme = useDocumentTheme;
+  if (globalTheme !== void 0)
+    CONFIG.globalTheme = globalTheme;
+  if (CONFIG.verbose)
+    console.log(CONFIG);
+  const keys = Object.keys(config);
+  keys.map((key) => setEach(key, config[key]));
+  (0, import_system.applyTypographySequence)();
+  (0, import_system.applySpacingSequence)();
+  (0, import_system.applyTimingSequence)();
+  (0, import_system.applyDocument)();
+  (0, import_system.applyReset)();
+  return CONFIG;
+};

package/dist/cjs/system/color.js

@@ -0,0 +1,169 @@
+"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, {
+  getColor: () => getColor,
+  getMediaColor: () => getMediaColor,
+  setColor: () => setColor,
+  setGradient: () => setGradient
+});
+module.exports = __toCommonJS(color_exports);
+var import_factory = require("../factory.js");
+var import_utils = require("@domql/utils");
+var import_utils2 = require("../utils");
+const getColor = (value, key) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  if (!(0, import_utils.isString)(value)) {
+    if (CONFIG.verbose)
+      console.warn(value, "- type for color is not valid");
+    return;
+  }
+  if (value.slice(0, 2) === "--")
+    return `var(${value})`;
+  if (key && value[key])
+    value = value[key];
+  const [name, alpha, tone] = (0, import_utils.isArray)(value) ? value : value.split(" ");
+  const { COLOR, GRADIENT } = CONFIG;
+  let val = COLOR[name] || GRADIENT[name];
+  if (!val) {
+    if (CONFIG.verbose)
+      console.warn("Can't find color ", name);
+    return value;
+  }
+  if (key) {
+    if (val[key])
+      val = val[key];
+    else if (CONFIG.verbose)
+      console.warn(value, " - does not have ", key);
+  }
+  let rgb = val.rgb;
+  if (rgb) {
+    if (tone) {
+      if (!val[tone]) {
+        const toHex = (0, import_utils2.rgbArrayToHex)(rgb.split(", ").map((v) => parseFloat(v)));
+        if (tone.slice(0, 1) === "-" || tone.slice(0, 1) === "+") {
+          rgb = (0, import_utils2.hexToRgbArray)((0, import_utils2.getColorShade)(toHex, parseFloat(tone))).join(", ");
+        } else {
+          const [r, g, b] = [...rgb.split(", ").map((v) => parseInt(v))];
+          const hsl = (0, import_utils2.rgbToHSL)(r, g, b);
+          const [h, s, l] = hsl;
+          const newRgb = (0, import_utils2.hslToRgb)(h, s, parseFloat(tone) / 100 * 255);
+          rgb = newRgb;
+        }
+        val[tone] = { rgb, var: `${val.var}-${tone}` };
+      } else
+        rgb = val[tone].rgb;
+    }
+    if (alpha)
+      return `rgba(${rgb}, ${alpha})`;
+    return CONFIG.useVariable ? `var(${val.var})` : `rgb(${rgb})`;
+  } else
+    return CONFIG.useVariable ? `var(${val.var})` : val.value;
+};
+const getMediaColor = (value, property, globalTheme) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  if (!globalTheme)
+    globalTheme = CONFIG.globalTheme;
+  if (!(0, import_utils.isString)(value)) {
+    if (CONFIG.verbose)
+      console.warn(value, "- type for color is not valid");
+    return;
+  }
+  if (value.slice(0, 2) === "--")
+    return { [property]: `var(${value})` };
+  const [name] = (0, import_utils.isArray)(value) ? value : value.split(" ");
+  const { COLOR, GRADIENT } = CONFIG;
+  const val = COLOR[name] || GRADIENT[name];
+  const isObj = (0, import_utils.isObject)(val);
+  if (isObj && val.value)
+    return { [property]: getColor(value, globalTheme) };
+  else if (isObj) {
+    if (globalTheme)
+      return { [property]: getColor(value, `@${globalTheme}`) };
+    else {
+      const obj = {};
+      for (const mediaName in val) {
+        const query = CONFIG.MEDIA[mediaName.slice(1)];
+        const media = `@media screen and ${query}`;
+        obj[media] = { [property]: getColor(value, mediaName) };
+      }
+      return obj;
+    }
+  } else {
+    if (CONFIG.verbose)
+      console.warn("Can't find color", value);
+    return { [property]: value };
+  }
+};
+const setColor = (val, key, suffix) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  if ((0, import_utils.isString)(val) && val.slice(0, 2) === "--")
+    val = getColor(val.slice(2));
+  if ((0, import_utils.isArray)(val)) {
+    return {
+      "@light": setColor(val[0], key, "light"),
+      "@dark": setColor(val[1], key, "dark")
+    };
+  }
+  if ((0, import_utils.isObject)(val)) {
+    const obj = {};
+    for (const variant in val)
+      obj[variant] = setColor(val[variant], key, variant.slice(0, 1) === "@" ? variant.slice(1) : variant);
+    return obj;
+  }
+  const CSSVar = `--color-${key}` + (suffix ? `-${suffix}` : "");
+  const [r, g, b, a = 1] = (0, import_utils2.colorStringToRgbaArray)(val.value || val);
+  const alpha = parseFloat(a.toFixed(2));
+  const rgb = `${r}, ${g}, ${b}`;
+  const value = `rgba(${rgb}, ${alpha})`;
+  if (CONFIG.useVariable) {
+    CONFIG.CSS_VARS[CSSVar] = value;
+  }
+  return {
+    var: CSSVar,
+    rgb,
+    alpha,
+    value
+  };
+};
+const setGradient = (val, key, suffix) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  if ((0, import_utils.isString)(val) && val.slice(0, 2) === "--")
+    val = getColor(val.slice(2));
+  if ((0, import_utils.isArray)(val)) {
+    return {
+      "@light": setGradient(val[0], key, "light"),
+      "@dark": setGradient(val[0], key, "dark")
+    };
+  }
+  if ((0, import_utils.isObject)(val)) {
+    const obj = {};
+    for (const variant in val)
+      obj[variant] = setGradient(val[variant], key, variant.slice(0, 1) === "@" ? variant.slice(1) : variant);
+    return obj;
+  }
+  const CSSVar = `--gradient-${key}` + (suffix ? `-${suffix}` : "");
+  if (CONFIG.useVariable) {
+    CONFIG.CSS_VARS[CSSVar] = val.value || val;
+  }
+  return {
+    var: CSSVar,
+    value: val.value || val
+  };
+};

package/dist/cjs/system/document.js

@@ -0,0 +1,35 @@
+"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 document_exports = {};
+__export(document_exports, {
+  applyDocument: () => applyDocument
+});
+module.exports = __toCommonJS(document_exports);
+var import_factory = require("../factory.js");
+var import_utils = require("../utils");
+const applyDocument = () => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  const { DOCUMENT, FONT_FAMILY, THEME, TYPOGRAPHY } = CONFIG;
+  return (0, import_utils.merge)(DOCUMENT, {
+    theme: THEME.document,
+    fontFamily: (0, import_utils.getDefaultOrFirstKey)(FONT_FAMILY),
+    fontSize: TYPOGRAPHY.base,
+    lineHeight: TYPOGRAPHY.lineHeight
+  });
+};

package/dist/cjs/system/font.js

@@ -0,0 +1,50 @@
+"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, {
+  getFontFamily: () => getFontFamily,
+  setFont: () => setFont,
+  setFontFamily: () => setFontFamily
+});
+module.exports = __toCommonJS(font_exports);
+var import_utils = require("@domql/utils");
+var import_factory = require("../factory.js");
+var import_utils2 = require("../utils");
+const setFont = (val, key) => {
+  const CSSvar = `--font-${key}`;
+  const fontFace = val[0] ? (0, import_utils2.getFontFaceEach)(key, val) : (0, import_utils2.setCustomFontMedia)(key, val.url);
+  return { var: CSSvar, value: val, fontFace };
+};
+const getFontFamily = (key, factory) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  const { FONT_FAMILY } = CONFIG;
+  return (0, import_utils2.getDefaultOrFirstKey)(factory || FONT_FAMILY, key);
+};
+const setFontFamily = (val, key) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  const { FONT_FAMILY, FONT_FAMILY_TYPES } = CONFIG;
+  let { value, type } = val;
+  if (val.isDefault)
+    FONT_FAMILY.default = key;
+  if ((0, import_utils.isObject)(value))
+    value = (0, import_utils2.arrayze)(value);
+  const CSSvar = `--font-family-${key}`;
+  const str = `${value.join(", ")}, ${FONT_FAMILY_TYPES[type]}`;
+  return { var: CSSvar, value: str, arr: value, type };
+};

package/dist/cjs/system/index.js

@@ -0,0 +1,26 @@
+"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 system_exports = {};
+module.exports = __toCommonJS(system_exports);
+__reExport(system_exports, require("./color.js"), module.exports);
+__reExport(system_exports, require("./theme.js"), module.exports);
+__reExport(system_exports, require("./font.js"), module.exports);
+__reExport(system_exports, require("./typography.js"), module.exports);
+__reExport(system_exports, require("./spacing.js"), module.exports);
+__reExport(system_exports, require("./timing.js"), module.exports);
+__reExport(system_exports, require("./document.js"), module.exports);
+__reExport(system_exports, require("./svg.js"), module.exports);
+__reExport(system_exports, require("./reset.js"), module.exports);

package/dist/cjs/system/reset.js

@@ -0,0 +1,83 @@
+"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 reset_exports = {};
+__export(reset_exports, {
+  applyReset: () => applyReset
+});
+module.exports = __toCommonJS(reset_exports);
+var import_factory = require("../factory.js");
+var import__ = require(".");
+var import_utils = require("@domql/utils");
+const applyReset = (reset = {}) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  const { CSS_VARS, RESET, TYPOGRAPHY, DOCUMENT } = CONFIG;
+  if (RESET) {
+    if (RESET[":root"]) {
+      const configReset = RESET;
+      const configTemplates = TYPOGRAPHY.templates;
+      configReset.body = {
+        ...(0, import__.getMediaTheme)("document", `@${CONFIG.globalTheme}`),
+        ...configTemplates.body
+      };
+      configReset.h1 = configTemplates.h1;
+      configReset.h2 = configTemplates.h2;
+      configReset.h3 = configTemplates.h3;
+      configReset.h4 = configTemplates.h4;
+      configReset.h5 = configTemplates.h5;
+      configReset.h6 = configTemplates.h6;
+    }
+    const { body, ...templates } = TYPOGRAPHY.templates;
+    return (0, import_utils.deepMerge)((0, import_utils.merge)(RESET, reset), {
+      html: {
+        position: "absolute",
+        overflow: "hidden",
+        width: "100%",
+        height: "100%",
+        top: "0",
+        left: "0",
+        margin: "0",
+        WebkitFontSmoothing: "antialiased",
+        transform: "translate3d(0, 0, 1px)",
+        scrollBehavior: "smooth",
+        fontSize: TYPOGRAPHY.browserDefault + "px",
+        fontFamily: DOCUMENT.fontFamily,
+        lineHeight: DOCUMENT.lineHeight
+      },
+      body: {
+        boxSizing: "border-box",
+        height: "100%",
+        margin: 0,
+        fontFamily: DOCUMENT.fontFamily,
+        fontSize: TYPOGRAPHY.base / TYPOGRAPHY.browserDefault + CONFIG.UNIT.default,
+        ...CONFIG.useDocumentTheme ? (0, import__.getMediaTheme)("document", `@${CONFIG.globalTheme}`) : {},
+        ...templates,
+        ...body
+      },
+      // form elements
+      fieldset: {
+        border: 0,
+        padding: 0,
+        margin: 0
+      },
+      "select, input": {
+        fontFamily: DOCUMENT.fontFamily
+      }
+    });
+  }
+};

package/dist/cjs/system/spacing.js

@@ -0,0 +1,129 @@
+"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 spacing_exports = {};
+__export(spacing_exports, {
+  applySpacingSequence: () => applySpacingSequence,
+  getSpacingBasedOnRatio: () => getSpacingBasedOnRatio,
+  getSpacingByKey: () => getSpacingByKey
+});
+module.exports = __toCommonJS(spacing_exports);
+var import_factory = require("../factory.js");
+var import_utils = require("@domql/utils");
+var import_utils2 = require("../utils");
+const runThroughMedia = (sequenceProps) => {
+  for (const prop in sequenceProps) {
+    const mediaProps = sequenceProps[prop];
+    if (prop.slice(0, 1) === "@") {
+      const { type, base, ratio, range, subSequence, h1Matches, unit } = sequenceProps;
+      (0, import_utils2.merge)(mediaProps, {
+        type,
+        base,
+        ratio,
+        range,
+        subSequence,
+        h1Matches,
+        unit,
+        sequence: {},
+        scales: {},
+        templates: {},
+        vars: {}
+      });
+      (0, import_utils2.generateSequence)(mediaProps);
+      const mediaName = prop.slice(1);
+      (0, import_utils2.applySequenceVars)(mediaProps, mediaName);
+    }
+  }
+};
+const applySpacingSequence = () => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  const { SPACING } = CONFIG;
+  (0, import_utils2.generateSequence)(SPACING);
+  (0, import_utils2.applySequenceVars)(SPACING);
+  runThroughMedia(SPACING);
+};
+const getSequence = (sequenceProps) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  const { SPACING } = CONFIG;
+  if (!sequenceProps)
+    return SPACING;
+  const hasGenerated = Object.keys(sequenceProps.sequence).length > 0;
+  return hasGenerated ? sequenceProps : (0, import_utils2.generateSequence)(sequenceProps);
+};
+const getSpacingByKey = (value, propertyName = "padding", sequenceProps) => {
+  const sequence = getSequence(sequenceProps);
+  const stack = (0, import_utils2.arrayze)(value);
+  if (!stack)
+    return;
+  if ((0, import_utils.isString)(value) && value.includes("calc")) {
+    return { [propertyName]: value };
+  }
+  if (stack.length > 1) {
+    let suffix = "";
+    if (propertyName === "borderWidth") {
+      propertyName = "border";
+      suffix = "Width";
+    }
+    const directions = {
+      2: ["Block", "Inline"],
+      3: ["BlockStart", "Inline", "BlockEnd"],
+      4: ["BlockStart", "InlineEnd", "BlockEnd", "InlineStart"]
+    };
+    const wrapSequenceValueByDirection = (direction, i) => (0, import_utils2.getSequenceValuePropertyPair)(
+      stack[i],
+      propertyName + direction + suffix,
+      sequence
+    );
+    return directions[stack.length].map((dir, key) => wrapSequenceValueByDirection(dir, key));
+  }
+  return (0, import_utils2.getSequenceValuePropertyPair)(
+    value,
+    propertyName,
+    sequence
+  );
+};
+const getSpacingBasedOnRatio = (props, propertyName, val) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  const { SPACING } = CONFIG;
+  const { spacingRatio, unit } = props;
+  const value = val || props[propertyName];
+  if (spacingRatio) {
+    let sequenceProps = SPACING[spacingRatio];
+    if (!sequenceProps) {
+      const { type, base, range, subSequence } = SPACING;
+      sequenceProps = SPACING[spacingRatio] = (0, import_utils2.merge)({
+        ratio: spacingRatio,
+        type: type + "-" + spacingRatio,
+        unit,
+        sequence: {},
+        scales: {},
+        templates: {},
+        vars: {}
+      }, {
+        base,
+        range,
+        subSequence,
+        ratio: SPACING.ratio,
+        unit: SPACING.unit
+      });
+    }
+    (0, import_utils2.applySequenceVars)(sequenceProps, null, { useDefault: false });
+    return getSpacingByKey(value, propertyName, sequenceProps);
+  }
+  return getSpacingByKey(value, propertyName);
+};