@symbo.ls/scratch 2.10.149 → 2.10.156

package/dist/cjs/utils/font.js

@@ -0,0 +1,70 @@
+"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,
+  setCustomFont: () => setCustomFont,
+  setCustomFontMedia: () => setCustomFontMedia,
+  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) => url.split(/[#?]/)[0].split(".").pop().trim();
+const setInCustomFontMedia = (str) => `@font-face { ${str} }`;
+const setCustomFont = (name, url, weight) => `
+  font-family: '${name}';
+  font-style: normal;
+  ${weight && `font-weight: ${weight};`}
+  src: url('${url}') format('${getFontFormat(url)}');`;
+const setCustomFontMedia = (name, url, weight) => `@font-face {
+  ${setCustomFont(name, url, weight)}
+}`;
+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) => {
+  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,23 @@
+"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("./object.js"), module.exports);
+__reExport(utils_exports, require("./color.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);

package/dist/cjs/utils/object.js

@@ -0,0 +1,73 @@
+"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 object_exports = {};
+__export(object_exports, {
+  arrayze: () => arrayze,
+  deepMerge: () => deepMerge,
+  isArray: () => isArray,
+  isFunction: () => isFunction,
+  isObject: () => isObject,
+  isObjectLike: () => isObjectLike,
+  isString: () => isString,
+  merge: () => merge
+});
+module.exports = __toCommonJS(object_exports);
+const isString = (arg) => typeof arg === "string";
+const isArray = (arg) => Array.isArray(arg);
+const isObject = (arg) => {
+  if (arg === null)
+    return false;
+  return typeof arg === "object" && arg.constructor === Object;
+};
+const isObjectLike = (arg) => {
+  if (arg === null)
+    return false;
+  return typeof arg === "object";
+};
+const merge = (obj, original) => {
+  for (const e in original) {
+    const objProp = obj[e];
+    const originalProp = original[e];
+    if (objProp === void 0) {
+      obj[e] = originalProp;
+    }
+  }
+  return obj;
+};
+const deepMerge = (obj, obj2) => {
+  for (const e in obj2) {
+    const objProp = obj[e];
+    const obj2Prop = obj2[e];
+    if (objProp === void 0) {
+      obj[e] = obj2Prop;
+    } else if (isObjectLike(objProp) && isObject(obj2Prop)) {
+      deepMerge(objProp, obj2Prop);
+    }
+  }
+  return obj;
+};
+const arrayze = (val) => {
+  if (isString(val))
+    return val.split(" ");
+  if (isObject(val))
+    return Object.keys(val).map((v) => val[v]);
+  if (isArray(val))
+    return val;
+};
+const isFunction = (arg) => typeof arg === "function";

package/dist/cjs/utils/sequence.js

@@ -0,0 +1,199 @@
+"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 sequence_exports = {};
+__export(sequence_exports, {
+  findHeadingLetter: () => findHeadingLetter,
+  findHeadings: () => findHeadings,
+  generateSequence: () => generateSequence,
+  generateSubSequence: () => generateSubSequence,
+  getSequenceValue: () => getSequenceValue,
+  getSequenceValuePropertyPair: () => getSequenceValuePropertyPair,
+  numToLetterMap: () => numToLetterMap
+});
+module.exports = __toCommonJS(sequence_exports);
+var import_utils = require("@domql/utils");
+var import_utils2 = require("@symbo.ls/utils");
+var import_factory = require("../factory.js");
+const numToLetterMap = {
+  "-6": "U",
+  "-5": "V",
+  "-4": "W",
+  "-3": "X",
+  "-2": "Y",
+  "-1": "Z",
+  0: "A",
+  1: "B",
+  2: "C",
+  3: "D",
+  4: "E",
+  5: "F",
+  6: "G",
+  7: "H",
+  8: "I",
+  9: "J",
+  10: "K",
+  11: "L",
+  12: "M",
+  13: "N",
+  14: "O",
+  15: "P",
+  16: "Q",
+  17: "R",
+  18: "S",
+  19: "T"
+};
+const setSequenceValue = (props, sequenceProps) => {
+  const { key, variable, value, scaling, index } = props;
+  sequenceProps.sequence[key] = {
+    key,
+    decimal: ~~(value * 100) / 100,
+    val: ~~value,
+    scaling,
+    index,
+    variable
+  };
+  sequenceProps.scales[key] = scaling;
+  sequenceProps.vars[variable] = scaling + sequenceProps.unit;
+};
+const generateSubSequence = (props, sequenceProps) => {
+  const { key, base, value, ratio, variable, index } = props;
+  const next = value * ratio;
+  const diff = next - value;
+  const smallscale = diff / 1.618;
+  const valueRounded = ~~value;
+  const nextRounded = ~~next;
+  const diffRounded = nextRounded - valueRounded;
+  let arr = [];
+  const first = next - smallscale;
+  const second = value + smallscale;
+  const middle = (first + second) / 2;
+  if (diffRounded > 16)
+    arr = [first, middle, second];
+  else
+    arr = [first, second];
+  arr.map((v, k) => {
+    const scaling = ~~(v / base * 1e3) / 1e3;
+    const newVar = variable + (k + 1);
+    const props2 = {
+      key: key + (k + 1),
+      variable: newVar,
+      value: v,
+      scaling,
+      index: index + (k + 1) / 10
+    };
+    return setSequenceValue(props2, sequenceProps);
+  });
+};
+const switchSequenceOnNegative = (key, base, ratio) => {
+  return base * Math.pow(ratio, key);
+};
+const generateSequence = (sequenceProps) => {
+  const { type, base, ratio, range, subSequence } = sequenceProps;
+  const n = Math.abs(range[0]) + Math.abs(range[1]);
+  const prefix = "--" + (type && type.replace(".", "-")) + "-";
+  for (let i = 0; i <= n; i++) {
+    const key = range[1] - i;
+    const letterKey = numToLetterMap[key];
+    const value = switchSequenceOnNegative(key, base, ratio);
+    const scaling = ~~(value / base * 100) / 100;
+    const variable = prefix + letterKey;
+    const props = {
+      key: letterKey,
+      variable,
+      value,
+      base,
+      scaling,
+      ratio,
+      index: key
+    };
+    setSequenceValue(props, sequenceProps);
+    if (subSequence)
+      generateSubSequence(props, sequenceProps);
+  }
+  return sequenceProps;
+};
+const getSequenceValue = (value = "A", sequenceProps) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  const { UNIT } = CONFIG;
+  const {
+    sequence,
+    unit = UNIT.default,
+    useVariable
+  } = sequenceProps;
+  if ((0, import_utils.isString)(value) && value.slice(0, 2) === "--")
+    return `var(${value})`;
+  const prefix = `--${(0, import_utils2.toDashCase)(sequenceProps.type.replace(".", "-"))}-`;
+  const startsWithDashOrLetterRegex = /^-?[a-zA-Z]/i;
+  const startsWithDashOrLetter = startsWithDashOrLetterRegex.test(value);
+  if (value === "none" || value === "auto" || value === "unset" || value === "inherit" || value === "fit-content" || value === "min-content" || value === "max-content" || value.includes("calc") || !startsWithDashOrLetter)
+    return value;
+  const letterVal = value.toUpperCase();
+  const isNegative = letterVal.slice(0, 1) === "-" ? "-" : "";
+  let absValue = isNegative ? letterVal.slice(1) : letterVal;
+  let mediaName = "";
+  if (absValue.includes("-")) {
+    mediaName = "-" + absValue.split("-")[1].toLowerCase();
+    absValue = absValue.split("-")[0];
+  }
+  const varValue = (v) => `var(${prefix}${v}${mediaName})`;
+  if (absValue.includes("+")) {
+    const args = absValue.split("+");
+    const [first, second] = args;
+    const joint = `${varValue(first)} + ${varValue(second)}`;
+    return isNegative ? `calc((${joint}) * -1)` : `calc(${joint})`;
+  } else if (absValue.includes("-")) {
+    const args = absValue.split("-");
+    const [first, second] = args;
+    const joint = `${varValue(first)} - ${varValue(second)}`;
+    return isNegative ? `calc((${joint}) * -1)` : `calc(${joint})`;
+  }
+  if (!sequence[absValue] && absValue.length === 2) {
+    if (CONFIG.verbose)
+      console.warn(absValue, "- value is not found because `subSequence` is set to false");
+    absValue = absValue.slice(0, 1);
+  }
+  if (useVariable || CONFIG.useVariable) {
+    const varValue2 = `var(${prefix}${absValue}${mediaName})`;
+    return isNegative ? `calc(${varValue2} * -1)` : varValue2;
+  }
+  const sequenceItem = sequence ? sequence[absValue] : null;
+  if (!sequenceItem)
+    return console.warn("can't find", sequence, absValue);
+  if (unit === "ms" || unit === "s") {
+    return isNegative + sequenceItem.val + unit;
+  }
+  return isNegative + sequenceItem.scaling + unit;
+};
+const getSequenceValuePropertyPair = (value, propertyName, sequenceProps) => {
+  if (typeof value !== "string") {
+    console.warn(propertyName, value, "is not a string");
+    return {};
+  }
+  if (value === "-" || value === "")
+    return {};
+  return { [propertyName]: getSequenceValue(value, sequenceProps) };
+};
+const findHeadingLetter = (h1Matches, index) => numToLetterMap[h1Matches - index];
+const findHeadings = (propertyNames) => {
+  const { h1Matches, sequence } = propertyNames;
+  return new Array(6).fill(null).map((_, i) => {
+    const findLetter = findHeadingLetter(h1Matches, i);
+    return sequence[findLetter];
+  });
+};

package/dist/cjs/utils/sprite.js

@@ -0,0 +1,63 @@
+"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 sprite_exports = {};
+__export(sprite_exports, {
+  convertSvgToSymbol: () => convertSvgToSymbol,
+  generateSprite: () => generateSprite
+});
+module.exports = __toCommonJS(sprite_exports);
+var import_utils = require("@domql/utils");
+const generateSprite = (icons) => {
+  let sprite = '<svg aria-hidden="true" width="0" height="0" style="position:absolute">';
+  for (let key in icons) {
+    sprite += icons[key];
+  }
+  sprite += "</svg>";
+  return sprite;
+};
+const parseRootAttributes = (htmlString) => {
+  if (!(0, import_utils.isString)(htmlString)) {
+    return console.warn(`parseRootAttributes: ${htmlString} is not a string`);
+  }
+  let match = htmlString.match(/<svg\s+(.*?)>/);
+  if (!match || !match[1]) {
+    return {};
+  }
+  let attrString = match[1];
+  let attrs = attrString.match(/(\S+)=["']?((?:.(?!["']?\s+(?:\S+)=|\s*\/?[>"']))+.)["']?/gm);
+  return attrs.reduce((acc, attr) => {
+    let [key, value] = attr.split("=");
+    acc[key] = value.replace(/['"]/g, "");
+    return acc;
+  }, {});
+};
+const convertSvgToSymbol = (key, code) => {
+  const extractAttrs = parseRootAttributes(code);
+  const { width, height } = extractAttrs;
+  const viewBox = extractAttrs.viewBox || `0 0 ${width || 24} ${height || 24}`;
+  const xmlns = "http://www.w3.org/2000/svg";
+  let symbol = code.replace(
+    "<svg",
+    `<symbol id="${key}" xmlns="${xmlns}" viewBox="${viewBox}"`
+  );
+  symbol = symbol.replace(/width="[^\"]*/, "");
+  symbol = symbol.replace(/height="[^\"]*/, "");
+  symbol = symbol.replace("</svg", "</symbol");
+  return symbol;
+};

package/dist/cjs/utils/theme.js

@@ -0,0 +1,32 @@
+"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 theme_exports = {};
+__export(theme_exports, {
+  returnSubThemeOrDefault: () => returnSubThemeOrDefault
+});
+module.exports = __toCommonJS(theme_exports);
+const returnSubThemeOrDefault = (orig, theme) => {
+  if (!orig)
+    return;
+  if (orig.themes && orig.themes[theme])
+    return orig.themes[theme];
+  if (orig[theme])
+    return [orig, orig[theme]];
+  return orig;
+};

package/dist/cjs/utils/var.js

@@ -0,0 +1,64 @@
+"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 var_exports = {};
+__export(var_exports, {
+  applySequenceVars: () => applySequenceVars,
+  setVariables: () => setVariables
+});
+module.exports = __toCommonJS(var_exports);
+var import_factory = require("../factory.js");
+var import_utils = require("@domql/utils");
+const ENV = "development";
+const setVariables = (result, key) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  const { CSS_VARS } = CONFIG;
+  if ((0, import_utils.isObjectLike)(result.value)) {
+  } else {
+    CSS_VARS[result.var] = result.value;
+  }
+};
+const applySequenceVars = (props, mediaName, options = {}) => {
+  const CONFIG = (0, import_factory.getActiveConfig)();
+  const { UNIT, MEDIA, TIMING, CSS_VARS } = CONFIG;
+  const unit = props.unit || UNIT.default;
+  const { sequence, scales } = props;
+  for (const key in sequence) {
+    const item = sequence[key];
+    const value = (props.type === TIMING.type ? sequence[key].val : scales[key]) + unit;
+    if (mediaName) {
+      const query = MEDIA[mediaName];
+      if (!query) {
+        if (CONFIG.verbose)
+          console.warn("Can't find query ", query);
+      }
+      let underMediaQuery = CSS_VARS[`@media ${query}`];
+      if (!underMediaQuery)
+        underMediaQuery = CSS_VARS[`@media ${query}`] = {};
+      underMediaQuery[item.variable] = `var(${item.variable + "-" + mediaName})`;
+      CSS_VARS[item.variable + "-" + mediaName] = value;
+    } else {
+      if (options.useDefault === false) {
+        CSS_VARS[item.variable] = value;
+      } else {
+        CSS_VARS[item.variable + "-default"] = value;
+        CSS_VARS[item.variable] = `var(${item.variable + "-default"})`;
+      }
+    }
+  }
+};

package/dist/esm/defaultConfig/animation.js

@@ -0,0 +1,4 @@
+const ANIMATION = {};
+export {
+  ANIMATION
+};

package/dist/esm/defaultConfig/cases.js

@@ -0,0 +1,4 @@
+const CASES = {};
+export {
+  CASES
+};

package/dist/esm/defaultConfig/color.js

@@ -0,0 +1,12 @@
+var proto = {
+  // eslint-disable-line
+  name: "",
+  value: "",
+  themes: {}
+};
+const COLOR = {};
+const GRADIENT = {};
+export {
+  COLOR,
+  GRADIENT
+};

package/dist/esm/defaultConfig/document.js

@@ -0,0 +1,4 @@
+const DOCUMENT = {};
+export {
+  DOCUMENT
+};

package/dist/esm/defaultConfig/font-family.js

@@ -0,0 +1,19 @@
+import { getFontFace } from "../utils";
+var defaultFont = {
+  // eslint-disable-line
+  name: "",
+  family: "",
+  type: ""
+};
+const FONT_FAMILY = {};
+const FONT_FAMILY_TYPES = {
+  "sans-serif": "Helvetica, Arial, sans-serif, --system-default",
+  serif: "Times New Roman, Georgia, serif, --system-default",
+  monospace: "Courier New, monospace, --system-default"
+};
+const FONT_FACE = getFontFace(FONT_FAMILY);
+export {
+  FONT_FACE,
+  FONT_FAMILY,
+  FONT_FAMILY_TYPES
+};

package/dist/esm/defaultConfig/font.js

@@ -0,0 +1,13 @@
+var defFont = {
+  // eslint-disable-line
+  name: "",
+  url: "",
+  fontStyle: "",
+  fontWeight: 500,
+  fontStretch: "normal",
+  fontOpticalSizing: "auto"
+};
+const FONT = {};
+export {
+  FONT
+};

package/dist/esm/defaultConfig/icons.js

@@ -0,0 +1,4 @@
+const ICONS = {};
+export {
+  ICONS
+};

package/dist/esm/defaultConfig/index.js

@@ -0,0 +1,20 @@
+export * from "./sequence.js";
+export * from "./unit.js";
+export * from "./typography.js";
+export * from "./font.js";
+export * from "./font-family.js";
+export * from "./media.js";
+export * from "./spacing.js";
+export * from "./color.js";
+export * from "./theme.js";
+export * from "./icons.js";
+export * from "./timing.js";
+export * from "./document.js";
+export * from "./responsive.js";
+export * from "./cases.js";
+export * from "./animation.js";
+export * from "./svg.js";
+const RESET = {};
+export {
+  RESET
+};

package/dist/esm/defaultConfig/media.js

@@ -0,0 +1,19 @@
+const MEDIA = {
+  tv: "(min-width: 2780px)",
+  screenL: "(max-width: 1920px)",
+  screenM: "(max-width: 1680px)",
+  screenS: "(max-width: 1440px)",
+  tabletL: "(max-width: 1366px)",
+  tabletM: "(max-width: 1280px)",
+  tabletS: "(max-width: 1024px)",
+  mobileL: "(max-width: 768px)",
+  mobileM: "(max-width: 560px)",
+  mobileS: "(max-width: 480px)",
+  mobileXS: "(max-width: 375px)",
+  light: "(prefers-color-scheme: light)",
+  dark: "(prefers-color-scheme: dark)",
+  print: "print"
+};
+export {
+  MEDIA
+};

package/dist/esm/defaultConfig/responsive.js

@@ -0,0 +1,28 @@
+const BREAKPOINTS = {
+  screenL: 1920,
+  screenM: 1680,
+  screenS: 1440,
+  tabletL: 1366,
+  tabletM: 1280,
+  tabletS: 1024,
+  mobileL: 768,
+  mobileM: 560,
+  mobileS: 480,
+  mobileXS: 375
+};
+const DEVICES = {
+  screenL: [1920, 1024],
+  screenM: [1680, 1024],
+  screenS: [1440, 978],
+  tabletL: [1366, 926],
+  tabletM: [1280, 768],
+  tabletS: [1024, 768],
+  mobileL: [768, 375],
+  mobileM: [560, 768],
+  mobileS: [480, 768],
+  mobileXS: [375, 768]
+};
+export {
+  BREAKPOINTS,
+  DEVICES
+};