@symbo.ls/shorthand 2.34.32 → 2.34.33

package/dist/cjs/decode.js

@@ -0,0 +1,182 @@
+"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 decode_exports = {};
+__export(decode_exports, {
+  decode: () => decode,
+  expand: () => expand,
+  parse: () => parse
+});
+module.exports = __toCommonJS(decode_exports);
+var import_registry = require("./registry.js");
+function decode(str) {
+  if (!str || typeof str !== "string") return {};
+  const obj = {};
+  const tokens = tokenize(str);
+  for (const token of tokens) {
+    if (token.startsWith("!")) {
+      const abbr2 = token.slice(1);
+      const prop2 = import_registry.abbrToProp[abbr2] || abbr2;
+      obj[prop2] = false;
+      continue;
+    }
+    const colonIdx = token.indexOf(":");
+    if (colonIdx === -1) {
+      const prop2 = import_registry.abbrToProp[token] || token;
+      obj[prop2] = true;
+      continue;
+    }
+    const abbr = token.slice(0, colonIdx);
+    const rawVal = token.slice(colonIdx + 1);
+    const prop = import_registry.abbrToProp[abbr] || abbr;
+    if (rawVal.includes(",")) {
+      obj[prop] = rawVal.split(",").map(decodeValue);
+      continue;
+    }
+    obj[prop] = decodeValue(rawVal);
+  }
+  return obj;
+}
+function tokenize(str) {
+  return str.trim().split(/\s+/).filter(Boolean);
+}
+function decodeValue(val) {
+  const str = val.replace(/_/g, " ");
+  if (/^-?\d+(\.\d+)?$/.test(str)) {
+    return Number(str);
+  }
+  return str;
+}
+function decodeInlineValue(val) {
+  return val.replace(/_/g, " ");
+}
+function decodeInline(str) {
+  if (!str || typeof str !== "string") return {};
+  const obj = {};
+  const tokens = tokenize(str);
+  for (const token of tokens) {
+    if (token.startsWith("!")) {
+      const abbr2 = token.slice(1);
+      const prop2 = import_registry.abbrToProp[abbr2] || abbr2;
+      obj[prop2] = false;
+      continue;
+    }
+    const colonIdx = token.indexOf(":");
+    if (colonIdx === -1) {
+      const prop2 = import_registry.abbrToProp[token] || token;
+      obj[prop2] = true;
+      continue;
+    }
+    const abbr = token.slice(0, colonIdx);
+    const rawVal = token.slice(colonIdx + 1);
+    const prop = import_registry.abbrToProp[abbr] || abbr;
+    if (rawVal.includes(",")) {
+      obj[prop] = rawVal.split(",").map(decodeInlineValue);
+      continue;
+    }
+    obj[prop] = decodeInlineValue(rawVal);
+  }
+  return obj;
+}
+function expand(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) {
+    return obj.map(function(item) {
+      if (item !== null && typeof item === "object") return expand(item);
+      return item;
+    });
+  }
+  const result = {};
+  for (const key in obj) {
+    const val = obj[key];
+    if ((0, import_registry.isComponentKey)(key)) {
+      result[key] = expandVal(val);
+      continue;
+    }
+    const fullKey = import_registry.abbrToProp[key] || key;
+    if ((0, import_registry.isSelectorKey)(key) && fullKey === key) {
+      result[key] = expandVal(val);
+      continue;
+    }
+    if (import_registry.PRESERVE_VALUE_KEYS.has(fullKey) || import_registry.PRESERVE_VALUE_KEYS.has(key)) {
+      result[fullKey] = val;
+      continue;
+    }
+    result[fullKey] = expandVal(val);
+  }
+  return result;
+}
+function expandVal(val) {
+  if (val === null || val === void 0) return val;
+  if (typeof val === "function") return val;
+  if (Array.isArray(val)) {
+    return val.map(function(item) {
+      if (item !== null && typeof item === "object") return expand(item);
+      return item;
+    });
+  }
+  if (typeof val === "object") return expand(val);
+  return val;
+}
+function parse(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) {
+    return obj.map(function(item) {
+      if (item !== null && typeof item === "object") return parse(item);
+      return item;
+    });
+  }
+  const result = {};
+  if (typeof obj.in === "string") {
+    const decoded = decodeInline(obj.in);
+    for (const prop in decoded) {
+      result[prop] = decoded[prop];
+    }
+  }
+  for (const key in obj) {
+    if (key === "in") continue;
+    const val = obj[key];
+    if ((0, import_registry.isComponentKey)(key)) {
+      result[key] = parseVal(val);
+      continue;
+    }
+    const fullKey = import_registry.abbrToProp[key] || key;
+    if ((0, import_registry.isSelectorKey)(key) && fullKey === key) {
+      result[key] = parseVal(val);
+      continue;
+    }
+    if (import_registry.PRESERVE_VALUE_KEYS.has(fullKey) || import_registry.PRESERVE_VALUE_KEYS.has(key)) {
+      result[fullKey] = val;
+      continue;
+    }
+    result[fullKey] = parseVal(val);
+  }
+  return result;
+}
+function parseVal(val) {
+  if (val === null || val === void 0) return val;
+  if (typeof val === "function") return val;
+  if (Array.isArray(val)) {
+    return val.map(function(item) {
+      if (item !== null && typeof item === "object") return parse(item);
+      return item;
+    });
+  }
+  if (typeof val === "object") return parse(val);
+  return val;
+}

package/dist/cjs/encode.js

@@ -0,0 +1,180 @@
+"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 encode_exports = {};
+__export(encode_exports, {
+  encode: () => encode,
+  shorten: () => shorten,
+  stringify: () => stringify
+});
+module.exports = __toCommonJS(encode_exports);
+var import_registry = require("./registry.js");
+function encode(obj) {
+  if (!obj || typeof obj !== "object") return "";
+  const tokens = [];
+  for (const prop in obj) {
+    const val = obj[prop];
+    if (typeof val === "function") continue;
+    if (val !== null && typeof val === "object" && !Array.isArray(val)) continue;
+    if (val === void 0) continue;
+    const abbr = import_registry.propToAbbr[prop] || prop;
+    if (val === true) {
+      tokens.push(abbr);
+    } else if (val === false) {
+      tokens.push("!" + abbr);
+    } else if (Array.isArray(val)) {
+      const items = val.map((item) => encodeValue(item));
+      tokens.push(abbr + ":" + items.join(","));
+    } else {
+      tokens.push(abbr + ":" + encodeValue(val));
+    }
+  }
+  return tokens.join(" ");
+}
+function encodeValue(val) {
+  const str = String(val);
+  return str.replace(/ /g, "_");
+}
+function shorten(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) {
+    return obj.map(function(item) {
+      if (item !== null && typeof item === "object") return shorten(item);
+      return item;
+    });
+  }
+  const result = {};
+  for (const key in obj) {
+    const val = obj[key];
+    if ((0, import_registry.isComponentKey)(key)) {
+      result[key] = shortenVal(val);
+      continue;
+    }
+    if ((0, import_registry.isSelectorKey)(key)) {
+      result[key] = shortenVal(val);
+      continue;
+    }
+    const shortKey = import_registry.propToAbbr[key] || key;
+    if (import_registry.PRESERVE_VALUE_KEYS.has(key) || import_registry.PRESERVE_VALUE_KEYS.has(shortKey)) {
+      result[shortKey] = val;
+      continue;
+    }
+    result[shortKey] = shortenVal(val);
+  }
+  return result;
+}
+function shortenVal(val) {
+  if (val === null || val === void 0) return val;
+  if (typeof val === "function") return val;
+  if (Array.isArray(val)) {
+    return val.map(function(item) {
+      if (item !== null && typeof item === "object") return shorten(item);
+      return item;
+    });
+  }
+  if (typeof val === "object") return shorten(val);
+  return val;
+}
+function stringify(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) {
+    return obj.map(function(item) {
+      if (item !== null && typeof item === "object") return stringify(item);
+      return item;
+    });
+  }
+  const result = {};
+  const tokens = [];
+  for (const key in obj) {
+    const val = obj[key];
+    if ((0, import_registry.isComponentKey)(key)) {
+      result[key] = stringifyVal(val);
+      continue;
+    }
+    if ((0, import_registry.isSelectorKey)(key)) {
+      result[key] = stringifyVal(val);
+      continue;
+    }
+    const shortKey = import_registry.propToAbbr[key] || key;
+    if (import_registry.PRESERVE_VALUE_KEYS.has(key) || import_registry.PRESERVE_VALUE_KEYS.has(shortKey)) {
+      result[shortKey] = val;
+      continue;
+    }
+    if (typeof val === "function") {
+      result[shortKey] = val;
+      continue;
+    }
+    if (val === null || val === void 0) {
+      result[shortKey] = val;
+      continue;
+    }
+    if (import_registry.SKIP_INLINE_KEYS.has(key) || import_registry.SKIP_INLINE_KEYS.has(shortKey)) {
+      result[shortKey] = val;
+      continue;
+    }
+    if (Array.isArray(val)) {
+      const hasObjects = val.some(function(item) {
+        return item !== null && typeof item === "object";
+      });
+      if (hasObjects) {
+        result[shortKey] = val.map(function(item) {
+          if (item !== null && typeof item === "object") return stringify(item);
+          return item;
+        });
+        continue;
+      }
+      if (val.length <= 1) {
+        result[shortKey] = val;
+        continue;
+      }
+      tokens.push(shortKey + ":" + val.map(encodeValue).join(","));
+      continue;
+    }
+    if (typeof val === "object") {
+      result[shortKey] = stringify(val);
+      continue;
+    }
+    if (val === true) {
+      tokens.push(shortKey);
+    } else if (val === false) {
+      tokens.push("!" + shortKey);
+    } else if (typeof val === "number") {
+      result[shortKey] = val;
+    } else if (typeof val === "string" && (val.includes(",") || val.includes("_"))) {
+      result[shortKey] = val;
+    } else {
+      tokens.push(shortKey + ":" + encodeValue(val));
+    }
+  }
+  if (tokens.length) {
+    result.in = tokens.join(" ");
+  }
+  return result;
+}
+function stringifyVal(val) {
+  if (val === null || val === void 0) return val;
+  if (typeof val === "function") return val;
+  if (Array.isArray(val)) {
+    return val.map(function(item) {
+      if (item !== null && typeof item === "object") return stringify(item);
+      return item;
+    });
+  }
+  if (typeof val === "object") return stringify(val);
+  return val;
+}

package/dist/cjs/index.js

@@ -0,0 +1,37 @@
+"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 index_exports = {};
+__export(index_exports, {
+  PRESERVE_VALUE_KEYS: () => import_registry.PRESERVE_VALUE_KEYS,
+  SKIP_INLINE_KEYS: () => import_registry.SKIP_INLINE_KEYS,
+  abbrToProp: () => import_registry.abbrToProp,
+  decode: () => import_decode.decode,
+  encode: () => import_encode.encode,
+  expand: () => import_decode.expand,
+  isComponentKey: () => import_registry.isComponentKey,
+  isSelectorKey: () => import_registry.isSelectorKey,
+  parse: () => import_decode.parse,
+  propToAbbr: () => import_registry.propToAbbr,
+  shorten: () => import_encode.shorten,
+  stringify: () => import_encode.stringify
+});
+module.exports = __toCommonJS(index_exports);
+var import_encode = require("./encode.js");
+var import_decode = require("./decode.js");
+var import_registry = require("./registry.js");

package/dist/cjs/package.json

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

package/dist/cjs/registry.js

@@ -0,0 +1,612 @@
+"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 registry_exports = {};
+__export(registry_exports, {
+  PRESERVE_VALUE_KEYS: () => PRESERVE_VALUE_KEYS,
+  SKIP_INLINE_KEYS: () => SKIP_INLINE_KEYS,
+  abbrToProp: () => abbrToProp,
+  isComponentKey: () => isComponentKey,
+  isSelectorKey: () => isSelectorKey,
+  propToAbbr: () => propToAbbr
+});
+module.exports = __toCommonJS(registry_exports);
+const propToAbbr = {
+  // ── Core DOMQL Properties ──
+  attr: "at",
+  childExtends: "cex",
+  childExtendsRecursive: "cexr",
+  childProps: "cp",
+  children: "ch",
+  childrenAs: "cha",
+  class: "cl",
+  content: "cnt",
+  context: "ctx",
+  data: "dt",
+  extends: "ext",
+  hide: "hd",
+  html: "htm",
+  if: "if",
+  ignoreChildExtend: "icex",
+  key: "ky",
+  query: "qy",
+  routes: "rt",
+  scope: "scp",
+  show: "shw",
+  state: "st",
+  style: "sy",
+  tag: "tg",
+  text: "tx",
+  // ── Symbols Shorthand Props ──
+  align: "aln",
+  boxSize: "bsz",
+  flow: "fl",
+  heightRange: "hr",
+  horizontalInset: "hi",
+  round: "rnd",
+  shadow: "shd",
+  size: "sz",
+  templateColumns: "tcol",
+  verticalInset: "vi",
+  widthRange: "wr",
+  wrap: "wrp",
+  // ── Box / Sizing ──
+  aspectRatio: "ar",
+  blockSize: "bks",
+  boxSizing: "bxs",
+  height: "h",
+  inlineSize: "ins",
+  margin: "m",
+  marginBottom: "mb",
+  marginLeft: "ml",
+  marginRight: "mr",
+  marginTop: "mt",
+  maxBlockSize: "mxbs",
+  maxHeight: "mxh",
+  maxInlineSize: "mxis",
+  maxWidth: "mxw",
+  minBlockSize: "mnbs",
+  minHeight: "mnh",
+  minInlineSize: "mnis",
+  minWidth: "mnw",
+  padding: "p",
+  paddingBottom: "pb",
+  paddingInline: "pil",
+  paddingLeft: "pl",
+  paddingRight: "pr",
+  paddingTop: "pt",
+  width: "w",
+  // ── Flexbox ──
+  alignContent: "ac",
+  alignItems: "ai",
+  alignSelf: "as",
+  flex: "fx",
+  flexBasis: "fxb",
+  flexDirection: "fxd",
+  flexFlow: "fxf",
+  flexGrow: "fxg",
+  flexShrink: "fxs",
+  flexWrap: "fxw",
+  gap: "g",
+  justifyContent: "jc",
+  justifyItems: "ji",
+  justifySelf: "js",
+  order: "od",
+  placeContent: "pcn",
+  placeItems: "pit",
+  placeSelf: "psl",
+  rowGap: "rg",
+  // ── Grid ──
+  columnGap: "cg",
+  gridArea: "ga",
+  gridAutoColumns: "gac",
+  gridAutoFlow: "gaf",
+  gridAutoRows: "gar",
+  gridColumn: "gc",
+  gridColumnEnd: "gce",
+  gridColumnStart: "gcs",
+  gridRow: "gr",
+  gridRowEnd: "gre",
+  gridRowStart: "grs",
+  gridTemplateAreas: "gta",
+  gridTemplateColumns: "gtc",
+  gridTemplateRows: "gtr",
+  // ── Position ──
+  bottom: "bot",
+  float: "flt",
+  inset: "ist",
+  left: "lft",
+  position: "pos",
+  right: "rgt",
+  top: "tp",
+  zIndex: "zi",
+  // ── Display / Visibility ──
+  clear: "clr",
+  contain: "ctn",
+  cursor: "cur",
+  display: "d",
+  opacity: "op",
+  overflow: "ov",
+  overflowX: "ovx",
+  overflowY: "ovy",
+  pointerEvents: "pe",
+  resize: "rsz",
+  userSelect: "us",
+  visibility: "vis",
+  // ── Color / Theme ──
+  background: "bg",
+  backgroundAttachment: "bga",
+  backgroundBlendMode: "bgbm",
+  backgroundClip: "bgcl",
+  backgroundColor: "bgc",
+  backgroundImage: "bgi",
+  backgroundOrigin: "bgo",
+  backgroundPosition: "bgp",
+  backgroundPositionX: "bgpx",
+  backgroundPositionY: "bgpy",
+  backgroundRepeat: "bgr",
+  backgroundRepeatX: "bgrx",
+  backgroundRepeatY: "bgry",
+  backgroundSize: "bgs",
+  color: "c",
+  theme: "thm",
+  themeModifier: "thmm",
+  // ── Border ──
+  border: "bd",
+  borderBottom: "bdb",
+  borderBottomLeftRadius: "bdblr",
+  borderBottomRightRadius: "bdbrr",
+  borderCollapse: "bdcl",
+  borderColor: "bdc",
+  borderImage: "bdi",
+  borderImageOutset: "bdio",
+  borderImageRepeat: "bdir",
+  borderImageSlice: "bdis",
+  borderImageSource: "bdisrc",
+  borderImageWidth: "bdiw",
+  borderLeft: "bdl",
+  borderRadius: "bdr",
+  borderRight: "bdrg",
+  borderSpacing: "bdsp",
+  borderStyle: "bdst",
+  borderTop: "bdt",
+  borderTopLeftRadius: "bdtlr",
+  borderTopRightRadius: "bdtrr",
+  borderWidth: "bdw",
+  // ── Outline ──
+  outline: "ol",
+  outlineColor: "olc",
+  outlineOffset: "olo",
+  outlineStyle: "ols",
+  outlineWidth: "olw",
+  // ── Shadow ──
+  boxShadow: "bxsh",
+  textShadow: "txsh",
+  // ── Typography ──
+  direction: "dir",
+  fontDisplay: "fdi",
+  fontFamily: "ff",
+  fontFeatureSettings: "ffs",
+  fontKerning: "fk",
+  fontOpticalSizing: "fos",
+  fontPalette: "fpl",
+  fontSize: "fs",
+  fontSizeAdjust: "fsa",
+  fontSmooth: "fsm",
+  fontStretch: "fsr",
+  fontStyle: "fsy",
+  fontSynthesis: "fsyn",
+  fontVariant: "fv",
+  fontVariationSettings: "fvs",
+  fontWeight: "fw",
+  hyphens: "hyp",
+  letterSpacing: "ls",
+  lineHeight: "lh",
+  tabSize: "tsz",
+  textAlign: "ta",
+  textDecoration: "td",
+  textDecorationColor: "tdc",
+  textDecorationLine: "tdl",
+  textDecorationStyle: "tds",
+  textIndent: "ti",
+  textOverflow: "tov",
+  textStroke: "tsk",
+  textTransform: "tt",
+  unicodeBidi: "ub",
+  verticalAlign: "va",
+  whiteSpace: "ws",
+  wordBreak: "wbr",
+  wordSpacing: "wsp",
+  wordWrap: "wwr",
+  writingMode: "wm",
+  // ── List / Table ──
+  captionSide: "cps",
+  counterIncrement: "ci",
+  counterReset: "cr",
+  emptyCells: "ec",
+  listStyle: "lst",
+  listStyleImage: "lsi",
+  listStylePosition: "lsp",
+  listStyleType: "lsty",
+  quotes: "qt",
+  tableLayout: "tl",
+  // ── Column ──
+  columnCount: "cc",
+  columnFill: "cf",
+  columnRule: "crl",
+  columnRuleColor: "crlc",
+  columnRuleStyle: "crls",
+  columnRuleWidth: "crlw",
+  columnSpan: "cspn",
+  columnWidth: "cwi",
+  columns: "col",
+  // ── Filter / Effects ──
+  backdropFilter: "bdf",
+  boxDecorationBreak: "bxdb",
+  clipPath: "cpth",
+  filter: "fil",
+  isolation: "iso",
+  mixBlendMode: "mbm",
+  objectFit: "obf",
+  objectPosition: "obp",
+  perspective: "prs",
+  perspectiveOrigin: "prso",
+  willChange: "wc",
+  // ── Transform ──
+  transform: "tf",
+  transformOrigin: "tfo",
+  transformStyle: "tfs",
+  // ── Transition ──
+  transition: "trn",
+  transitionDelay: "trnd",
+  transitionDuration: "trndr",
+  transitionProperty: "trnp",
+  transitionTimingFunction: "trntf",
+  // ── Animation ──
+  animation: "an",
+  animationDelay: "and",
+  animationDirection: "andr",
+  animationDuration: "andur",
+  animationFillMode: "anfm",
+  animationIterationCount: "anic",
+  animationName: "ann",
+  animationPlayState: "anps",
+  animationTimingFunction: "antf",
+  // ── Scroll ──
+  scrollBehavior: "sb",
+  scrollMargin: "smr",
+  scrollMarginBottom: "smrb",
+  scrollMarginLeft: "smrl",
+  scrollMarginRight: "smrr",
+  scrollMarginTop: "smrt",
+  scrollPadding: "spd",
+  scrollPaddingBottom: "spdb",
+  scrollPaddingLeft: "spdl",
+  scrollPaddingRight: "spdr",
+  scrollPaddingTop: "spdt",
+  scrollSnapAlign: "ssa",
+  scrollSnapStop: "sss",
+  scrollSnapType: "sst",
+  // ── Page Break ──
+  breakAfter: "bka",
+  breakBefore: "bkb",
+  breakInside: "bki",
+  pageBreakAfter: "pbka",
+  pageBreakBefore: "pbkb",
+  pageBreakInside: "pbki",
+  // ── HTML Attributes: Global ──
+  accessKey: "ack",
+  className: "cn",
+  contentEditable: "ced",
+  contextMenu: "cmu",
+  draggable: "drg",
+  hidden: "hid",
+  id: "id",
+  is: "is",
+  lang: "lng",
+  nonce: "nnc",
+  spellCheck: "spc",
+  tabIndex: "tbi",
+  title: "ttl",
+  translate: "trl",
+  // ── HTML Attributes: Form ──
+  accept: "acp",
+  acceptCharset: "accs",
+  action: "act",
+  autoComplete: "atc",
+  autoFocus: "atf",
+  capture: "cap",
+  challenge: "chg",
+  checked: "chk",
+  cols: "cls",
+  colSpan: "csn",
+  controls: "ctl",
+  default: "def",
+  defer: "dfr",
+  disabled: "dis",
+  encType: "ect",
+  form: "frm",
+  formAction: "fac",
+  formEncType: "fect",
+  formMethod: "fme",
+  formNoValidate: "fnv",
+  formTarget: "ftg",
+  high: "hgh",
+  inputMode: "imd",
+  kind: "knd",
+  label: "lbl",
+  list: "lis",
+  loop: "lp",
+  low: "lw",
+  max: "mx",
+  maxLength: "mxl",
+  method: "mtd",
+  min: "mn",
+  minLength: "mnl",
+  multiple: "mul",
+  muted: "mut",
+  name: "nm",
+  open: "opn",
+  optimum: "opt",
+  pattern: "ptn",
+  placeholder: "phd",
+  readOnly: "ro",
+  required: "req",
+  reversed: "rev",
+  rows: "rws",
+  rowSpan: "rsn",
+  selected: "sel",
+  span: "spn",
+  start: "srt",
+  step: "stp",
+  type: "typ",
+  value: "val",
+  // ── HTML Attributes: Link / Navigation ──
+  download: "dl",
+  href: "hrf",
+  hrefLang: "hrl",
+  ping: "png",
+  referrerPolicy: "rfp",
+  rel: "rl",
+  target: "tgt",
+  // ── HTML Attributes: Media ──
+  allow: "alw",
+  allowFullScreen: "afs",
+  allowPaymentRequest: "apr",
+  alt: "alt",
+  cellPadding: "cpg",
+  cellSpacing: "csg",
+  cite: "cit",
+  coords: "crd",
+  crossOrigin: "cor",
+  dateTime: "dtm",
+  fetchPriority: "fpr",
+  headers: "hds",
+  httpEquiv: "hte",
+  integrity: "itg",
+  isMap: "ism",
+  keyType: "kty",
+  loading: "ldg",
+  manifest: "mft",
+  media: "mda",
+  poster: "pst",
+  preload: "prl",
+  radioGroup: "rdg",
+  sandbox: "sbx",
+  scoped: "scod",
+  seamless: "sml",
+  shape: "shp",
+  sizes: "szs",
+  src: "src",
+  srcDoc: "srd",
+  srcLang: "srl",
+  srcSet: "srs",
+  useMap: "ump",
+  // ── HTML Attributes: ARIA ──
+  ariaActiveDescendant: "aad",
+  ariaAtomic: "aat",
+  ariaBusy: "abu",
+  ariaChecked: "achk",
+  ariaControls: "acl",
+  ariaCurrent: "acr",
+  ariaDescribedBy: "adb",
+  ariaDetails: "adt",
+  ariaDisabled: "adis",
+  ariaDropEffect: "ade",
+  ariaErrorMessage: "aem",
+  ariaExpanded: "aexp",
+  ariaGrabbed: "agr",
+  ariaHasPopup: "ahp",
+  ariaHidden: "ahid",
+  ariaInvalid: "ainv",
+  ariaLabel: "alb",
+  ariaLabelledBy: "alby",
+  ariaLive: "alv",
+  ariaModal: "amod",
+  ariaMultiSelectable: "ams",
+  ariaOrientation: "aor",
+  ariaOwns: "aow",
+  ariaPosInSet: "apis",
+  ariaPressed: "aprs",
+  ariaReadOnly: "aro",
+  ariaRelevant: "arl",
+  ariaRequired: "areq",
+  ariaSelected: "asel",
+  ariaSetSize: "assz",
+  ariaValueMax: "avmx",
+  ariaValueMin: "avmn",
+  ariaValueNow: "avn",
+  role: "role",
+  // ── Events: Lifecycle ──
+  onInit: "@in",
+  onRender: "@rn",
+  onUpdate: "@up",
+  onStateChange: "@sc",
+  onStateUpdate: "@su",
+  // ── Events: Mouse ──
+  onClick: "@ck",
+  onContextMenu: "@cm",
+  onDblClick: "@dc",
+  onMouseDown: "@md",
+  onMouseEnter: "@me",
+  onMouseLeave: "@ml",
+  onMouseMove: "@mm",
+  onMouseOut: "@mo",
+  onMouseOver: "@mv",
+  onMouseUp: "@mu",
+  // ── Events: Keyboard ──
+  onKeyDown: "@kd",
+  onKeyPress: "@kp",
+  onKeyUp: "@ku",
+  // ── Events: Focus ──
+  onBlur: "@bl",
+  onFocus: "@fc",
+  onFocusIn: "@fi",
+  onFocusOut: "@fo",
+  // ── Events: Form ──
+  onBeforeInput: "@bi",
+  onChange: "@cg",
+  onFormData: "@fd",
+  onInput: "@ip",
+  onInvalid: "@iv",
+  onReset: "@rs",
+  onSearch: "@sr",
+  onSelect: "@sl",
+  onSubmit: "@sm",
+  // ── Events: Touch ──
+  onTouchCancel: "@tc",
+  onTouchEnd: "@te",
+  onTouchMove: "@tm",
+  onTouchStart: "@ts",
+  // ── Events: Pointer ──
+  onPointerCancel: "@pc",
+  onPointerDown: "@pd",
+  onPointerEnter: "@pe",
+  onPointerLeave: "@ple",
+  onPointerMove: "@pm",
+  onPointerOut: "@po",
+  onPointerOver: "@pov",
+  onPointerUp: "@pu",
+  // ── Events: Drag ──
+  onDrag: "@dg",
+  onDragEnd: "@dge",
+  onDragEnter: "@dgn",
+  onDragLeave: "@dgl",
+  onDragOver: "@dgo",
+  onDragStart: "@dgs",
+  onDrop: "@dp",
+  // ── Events: Scroll / Resize ──
+  onResize: "@rz",
+  onScroll: "@scl",
+  onWheel: "@wh",
+  // ── Events: Clipboard ──
+  onCopy: "@cy",
+  onCut: "@ct",
+  onPaste: "@pt",
+  // ── Events: Composition ──
+  onCompositionEnd: "@cpe",
+  onCompositionStart: "@cps",
+  onCompositionUpdate: "@cpu",
+  // ── Events: Animation / Transition ──
+  onAnimationEnd: "@ae",
+  onAnimationIteration: "@ai",
+  onAnimationStart: "@as",
+  onTransitionEnd: "@tre",
+  onTransitionStart: "@trs",
+  // ── Events: Media ──
+  onAbort: "@ab",
+  onCanPlay: "@cap",
+  onCanPlayThrough: "@cpt",
+  onDurationChange: "@duc",
+  onEmptied: "@em",
+  onEncrypted: "@enc",
+  onEnded: "@end",
+  onError: "@er",
+  onLoad: "@ld",
+  onLoadedData: "@ldd",
+  onLoadedMetadata: "@ldm",
+  onPause: "@pa",
+  onPlay: "@pl",
+  onPlaying: "@plg",
+  onProgress: "@prg",
+  onRateChange: "@rc",
+  onSeeked: "@sk",
+  onSeeking: "@skg",
+  onStalled: "@stl",
+  onSuspend: "@ssp",
+  onTimeUpdate: "@tu",
+  onVolumeChange: "@vc",
+  onWaiting: "@wt",
+  // ── Special / Advanced ──
+  icon: "ico",
+  iconText: "ict",
+  lookup: "lkp",
+  router: "rtr",
+  shapeModifier: "shpm"
+};
+const abbrToProp = /* @__PURE__ */ Object.create(null);
+for (const prop in propToAbbr) {
+  abbrToProp[propToAbbr[prop]] = prop;
+}
+const seen = /* @__PURE__ */ Object.create(null);
+for (const prop in propToAbbr) {
+  const abbr = propToAbbr[prop];
+  if (seen[abbr]) {
+    throw new Error(
+      `Duplicate abbreviation "${abbr}" for "${prop}" \u2014 already used by "${seen[abbr]}"`
+    );
+  }
+  seen[abbr] = prop;
+}
+const PRESERVE_VALUE_KEYS = /* @__PURE__ */ new Set([
+  "state",
+  "st",
+  "scope",
+  "scp",
+  "attr",
+  "at",
+  "style",
+  "sy",
+  "data",
+  "dt",
+  "context",
+  "ctx",
+  "query",
+  "qy",
+  "class",
+  "cl"
+]);
+const SKIP_INLINE_KEYS = /* @__PURE__ */ new Set([
+  "text",
+  "tx",
+  "html",
+  "htm",
+  "content",
+  "cnt",
+  "placeholder",
+  "phd",
+  "src",
+  "href",
+  "hrf"
+]);
+function isComponentKey(key) {
+  return /^[A-Z]/.test(key);
+}
+function isSelectorKey(key) {
+  return /^[:@.!$>&]/.test(key) || key.startsWith("> ");
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@symbo.ls/shorthand",
   "description": "Shorthand syntax transpiler for Symbols properties",
   "author": "symbo.ls",
-  "version": "2.34.32",
+  "version": "2.34.33",
   "repository": "https://github.com/symbo-ls/smbls",
   "type": "module",
   "module": "src/index.js",
@@ -23,5 +23,5 @@
     "docs"
   ],
   "license": "ISC",
-  "gitHead": "99bd991fb87c092bcfd045ad358c15064a8b8c30"
+  "gitHead": "a7ecaaa2792aea530bf0b4cef625904c63a0272a"
 }