@aglyn/shared-data-enums 1.0.0-beta.143

package/src/lib/sx-property-aliases.d.ts

@@ -0,0 +1,129 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * One spelling per style property (AGL-2207).
+ *
+ * Node `sx` is an MUI `sx` record, and MUI honours TWO names for the same
+ * declaration: its system-prop aliases (`bgcolor`, `p`/`px`/`py`/…,
+ * `m`/`mx`/`my`/…) and the CSS longhands. The Styles panel only ever names
+ * the longhands — `buildStyleFieldGroups` declares `backgroundColor`, and
+ * `ElementStylesForm` reads `paddingTop`…`marginLeft` for the box model —
+ * so a stored alias RENDERS but reaches no field: the control shows empty,
+ * and clearing the field deletes a key that was never the one painting.
+ *
+ * The longhand is therefore canonical. Not because the renderer prefers it
+ * (it resolves both, so the renderer cannot arbitrate) but because the
+ * panel's field names are the only schema the product has.
+ *
+ * This module is the single table, plus the expansion every read/write
+ * seam applies. Nothing REMOVES the alias spelling from the corpus: live
+ * documents carry it, the Custom CSS builder is free-solo and its JSON tab
+ * takes any key at all, so an alias can arrive at any time. Expanding on
+ * read is what makes those documents editable; expanding the colliding
+ * keys on write is what makes clearing actually clear.
+ */
+/**
+ * Alias → the CSS longhands it stands for.
+ *
+ * Ground truth is MUI's own tables, not this file's memory:
+ * `@mui/system/styleFunctionSx/defaultSxConfig` gives
+ * `bgcolor.cssProperty === 'backgroundColor'`, and `@mui/system/spacing`
+ * builds its `CSS_PROPERTIES` table by crossing the two property roots
+ * (`m` is margin, `p` is padding) with six direction suffixes — `t` Top,
+ * `r` Right, `b` Bottom, `l` Left, `x` Left and Right, `y` Top and Bottom
+ * — and then points `paddingX`/`paddingY`/`marginX`/`marginY` at
+ * `px`/`py`/`mx`/`my`. `sx-property-aliases.spec.ts` asserts
+ * this table against those modules so a MUI upgrade cannot open a spelling
+ * we do not know about.
+ *
+ * Deliberately NOT here:
+ *
+ * - `p` and `m` map to the CSS shorthands `padding`/`margin` in MUI, but
+ *   the panel has no shorthand field — BoxStyler owns four per-side
+ *   controls — so they expand to the four longhands. That is exact for the
+ *   atomic values {@link isAtomicSxValue} admits and refused for the rest.
+ * - `padding`/`margin` themselves. They are real CSS properties whose
+ *   value may be a multi-side shorthand, and no panel field owns them
+ *   either; rewriting them is a value-parsing problem, not a naming one.
+ * - Logical properties (`paddingInline*`, `marginBlock*`, …). MUI lists
+ *   them in its spacing set, but each maps to the SAME-named CSS property
+ *   — they are not aliases, they are direction-agnostic properties whose
+ *   whole point is that they differ from `left`/`right` under RTL.
+ */
+export declare const SX_PROPERTY_ALIASES: Readonly<Record<string, readonly string[]>>;
+/** Every alias spelling, for guards and callers that only need the set. */
+export declare const SX_ALIAS_PROPERTIES: readonly string[];
+/** Whether `name` is a stray spelling of a canonical style property. */
+export declare function isSxAliasProperty(name: string): boolean;
+/** The canonical longhands `name` stands for; empty when it IS canonical. */
+export declare function canonicalSxProperties(name: string): readonly string[];
+/** Aliases that would write `property` — the keys an edit to it must clear. */
+export declare function sxAliasesFor(property: string): string[];
+/**
+ * Whether a value survives being copied onto EACH longhand an alias covers.
+ *
+ * A number does (`p: 2` → four `padding*: 2`, each through the same MUI
+ * spacing transform, so 16px on all four sides either way). A single-token
+ * string does (`px: '2rem'`). A multi-token string does NOT: a value like
+ * `'10px 20px'` is the CSS shorthand's own per-side syntax, and copying it
+ * onto `paddingTop` would silently turn 10px into a two-value declaration
+ * CSS drops. Those are left as they are: still rendering, still not editable,
+ * but not corrupted either. The panel has no control that could express
+ * them anyway.
+ *
+ * A responsive object (`{xs: 2, md: 4}`) is atomic when every slice is,
+ * because the expansion just carries the whole object onto each longhand
+ * and MUI resolves it per breakpoint exactly as before.
+ */
+export declare function isAtomicSxValue(value: unknown): boolean;
+/**
+ * Whether an alias key in this record could be expanded — the guard's
+ * question, and the identity fast-path's.
+ */
+export declare function hasExpandableSxAlias(sx: unknown): boolean;
+/** Options for {@link expandSxAliases}. */
+export interface ExpandSxAliasesOptions {
+    /**
+     * Expand only aliases that stand for one of these properties. Used by
+     * the panel's write seam, which must not rewrite keys the author is not
+     * editing. Omitted = expand every expandable alias.
+     */
+    only?: readonly string[];
+    /**
+     * Also expand nested records — the `@scheme dark` slice, breakpoint
+     * media keys, `&:hover` blocks. Off by default so a caller that only
+     * cares about the top level pays for nothing.
+     */
+    deep?: boolean;
+}
+/**
+ * Rewrites alias keys to their canonical longhands, IN PLACE in the key
+ * order (AGL-2207).
+ *
+ * Order is the whole correctness argument. MUI's `styleFunctionSx` walks
+ * `sx` with `for…in` and later keys overwrite earlier ones, so
+ * `{p: 2, paddingTop: 8}` renders 8px on top and `{paddingTop: 8, p: 2}`
+ * renders 2 × the spacing unit. Expanding each alias where it stands —
+ * rather than appending the longhands — reproduces both, so the expansion
+ * is a pure renaming of what already renders and never a restyle.
+ *
+ * Returns the input BY IDENTITY when there is nothing to expand, which is
+ * every node in a corpus once the presets stop writing aliases, so this
+ * sitting on a render path costs one key scan and no allocation.
+ */
+export declare function expandSxAliases<T>(sx: T, options?: ExpandSxAliasesOptions): T;
+export default expandSxAliases;

package/src/lib/sx-property-aliases.js

@@ -0,0 +1,231 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * One spelling per style property (AGL-2207).
+ *
+ * Node `sx` is an MUI `sx` record, and MUI honours TWO names for the same
+ * declaration: its system-prop aliases (`bgcolor`, `p`/`px`/`py`/…,
+ * `m`/`mx`/`my`/…) and the CSS longhands. The Styles panel only ever names
+ * the longhands — `buildStyleFieldGroups` declares `backgroundColor`, and
+ * `ElementStylesForm` reads `paddingTop`…`marginLeft` for the box model —
+ * so a stored alias RENDERS but reaches no field: the control shows empty,
+ * and clearing the field deletes a key that was never the one painting.
+ *
+ * The longhand is therefore canonical. Not because the renderer prefers it
+ * (it resolves both, so the renderer cannot arbitrate) but because the
+ * panel's field names are the only schema the product has.
+ *
+ * This module is the single table, plus the expansion every read/write
+ * seam applies. Nothing REMOVES the alias spelling from the corpus: live
+ * documents carry it, the Custom CSS builder is free-solo and its JSON tab
+ * takes any key at all, so an alias can arrive at any time. Expanding on
+ * read is what makes those documents editable; expanding the colliding
+ * keys on write is what makes clearing actually clear.
+ */ /**
+ * Alias → the CSS longhands it stands for.
+ *
+ * Ground truth is MUI's own tables, not this file's memory:
+ * `@mui/system/styleFunctionSx/defaultSxConfig` gives
+ * `bgcolor.cssProperty === 'backgroundColor'`, and `@mui/system/spacing`
+ * builds its `CSS_PROPERTIES` table by crossing the two property roots
+ * (`m` is margin, `p` is padding) with six direction suffixes — `t` Top,
+ * `r` Right, `b` Bottom, `l` Left, `x` Left and Right, `y` Top and Bottom
+ * — and then points `paddingX`/`paddingY`/`marginX`/`marginY` at
+ * `px`/`py`/`mx`/`my`. `sx-property-aliases.spec.ts` asserts
+ * this table against those modules so a MUI upgrade cannot open a spelling
+ * we do not know about.
+ *
+ * Deliberately NOT here:
+ *
+ * - `p` and `m` map to the CSS shorthands `padding`/`margin` in MUI, but
+ *   the panel has no shorthand field — BoxStyler owns four per-side
+ *   controls — so they expand to the four longhands. That is exact for the
+ *   atomic values {@link isAtomicSxValue} admits and refused for the rest.
+ * - `padding`/`margin` themselves. They are real CSS properties whose
+ *   value may be a multi-side shorthand, and no panel field owns them
+ *   either; rewriting them is a value-parsing problem, not a naming one.
+ * - Logical properties (`paddingInline*`, `marginBlock*`, …). MUI lists
+ *   them in its spacing set, but each maps to the SAME-named CSS property
+ *   — they are not aliases, they are direction-agnostic properties whose
+ *   whole point is that they differ from `left`/`right` under RTL.
+ */ export const SX_PROPERTY_ALIASES = Object.freeze({
+    bgcolor: [
+        'backgroundColor'
+    ],
+    p: [
+        'paddingTop',
+        'paddingRight',
+        'paddingBottom',
+        'paddingLeft'
+    ],
+    pt: [
+        'paddingTop'
+    ],
+    pr: [
+        'paddingRight'
+    ],
+    pb: [
+        'paddingBottom'
+    ],
+    pl: [
+        'paddingLeft'
+    ],
+    px: [
+        'paddingLeft',
+        'paddingRight'
+    ],
+    py: [
+        'paddingTop',
+        'paddingBottom'
+    ],
+    paddingX: [
+        'paddingLeft',
+        'paddingRight'
+    ],
+    paddingY: [
+        'paddingTop',
+        'paddingBottom'
+    ],
+    m: [
+        'marginTop',
+        'marginRight',
+        'marginBottom',
+        'marginLeft'
+    ],
+    mt: [
+        'marginTop'
+    ],
+    mr: [
+        'marginRight'
+    ],
+    mb: [
+        'marginBottom'
+    ],
+    ml: [
+        'marginLeft'
+    ],
+    mx: [
+        'marginLeft',
+        'marginRight'
+    ],
+    my: [
+        'marginTop',
+        'marginBottom'
+    ],
+    marginX: [
+        'marginLeft',
+        'marginRight'
+    ],
+    marginY: [
+        'marginTop',
+        'marginBottom'
+    ]
+});
+/** Every alias spelling, for guards and callers that only need the set. */ export const SX_ALIAS_PROPERTIES = Object.freeze(Object.keys(SX_PROPERTY_ALIASES));
+/** Whether `name` is a stray spelling of a canonical style property. */ export function isSxAliasProperty(name) {
+    return Object.prototype.hasOwnProperty.call(SX_PROPERTY_ALIASES, name);
+}
+/** The canonical longhands `name` stands for; empty when it IS canonical. */ export function canonicalSxProperties(name) {
+    var _SX_PROPERTY_ALIASES_name;
+    return (_SX_PROPERTY_ALIASES_name = SX_PROPERTY_ALIASES[name]) != null ? _SX_PROPERTY_ALIASES_name : [];
+}
+/** Aliases that would write `property` — the keys an edit to it must clear. */ export function sxAliasesFor(property) {
+    return SX_ALIAS_PROPERTIES.filter((alias)=>SX_PROPERTY_ALIASES[alias].includes(property));
+}
+const isPlainObject = (value)=>typeof value === 'object' && value !== null && !Array.isArray(value);
+/**
+ * Whether a value survives being copied onto EACH longhand an alias covers.
+ *
+ * A number does (`p: 2` → four `padding*: 2`, each through the same MUI
+ * spacing transform, so 16px on all four sides either way). A single-token
+ * string does (`px: '2rem'`). A multi-token string does NOT: a value like
+ * `'10px 20px'` is the CSS shorthand's own per-side syntax, and copying it
+ * onto `paddingTop` would silently turn 10px into a two-value declaration
+ * CSS drops. Those are left as they are: still rendering, still not editable,
+ * but not corrupted either. The panel has no control that could express
+ * them anyway.
+ *
+ * A responsive object (`{xs: 2, md: 4}`) is atomic when every slice is,
+ * because the expansion just carries the whole object onto each longhand
+ * and MUI resolves it per breakpoint exactly as before.
+ */ export function isAtomicSxValue(value) {
+    if (typeof value === 'number') return true;
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed.length > 0 && !/[\s,]/.test(trimmed);
+    }
+    if (isPlainObject(value)) {
+        const entries = Object.values(value);
+        return entries.length > 0 && entries.every(isAtomicSxValue);
+    }
+    return false;
+}
+/**
+ * Whether an alias key in this record could be expanded — the guard's
+ * question, and the identity fast-path's.
+ */ export function hasExpandableSxAlias(sx) {
+    if (!isPlainObject(sx)) return false;
+    for (const [key, value] of Object.entries(sx)){
+        if (isSxAliasProperty(key)) {
+            if (SX_PROPERTY_ALIASES[key].length === 1 || isAtomicSxValue(value)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Rewrites alias keys to their canonical longhands, IN PLACE in the key
+ * order (AGL-2207).
+ *
+ * Order is the whole correctness argument. MUI's `styleFunctionSx` walks
+ * `sx` with `for…in` and later keys overwrite earlier ones, so
+ * `{p: 2, paddingTop: 8}` renders 8px on top and `{paddingTop: 8, p: 2}`
+ * renders 2 × the spacing unit. Expanding each alias where it stands —
+ * rather than appending the longhands — reproduces both, so the expansion
+ * is a pure renaming of what already renders and never a restyle.
+ *
+ * Returns the input BY IDENTITY when there is nothing to expand, which is
+ * every node in a corpus once the presets stop writing aliases, so this
+ * sitting on a render path costs one key scan and no allocation.
+ */ export function expandSxAliases(sx, options) {
+    var _ref;
+    if (!isPlainObject(sx)) return sx;
+    const only = options == null ? void 0 : options.only;
+    const deep = (_ref = options == null ? void 0 : options.deep) != null ? _ref : false;
+    let changed = false;
+    const out = {};
+    for (const [key, value] of Object.entries(sx)){
+        const canonical = SX_PROPERTY_ALIASES[key];
+        const wanted = canonical && (!only || canonical.some((name)=>only.includes(name))) && (canonical.length === 1 || isAtomicSxValue(value));
+        if (wanted) {
+            changed = true;
+            for (const name of canonical)out[name] = value;
+            continue;
+        }
+        if (deep && isPlainObject(value)) {
+            const nested = expandSxAliases(value, options);
+            if (nested !== value) changed = true;
+            out[key] = nested;
+            continue;
+        }
+        out[key] = value;
+    }
+    return changed ? out : sx;
+}
+export default expandSxAliases;
+
+//# sourceMappingURL=sx-property-aliases.js.map

package/src/lib/sx-property-aliases.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/shared/data/enums/src/lib/sx-property-aliases.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * One spelling per style property (AGL-2207).\n *\n * Node `sx` is an MUI `sx` record, and MUI honours TWO names for the same\n * declaration: its system-prop aliases (`bgcolor`, `p`/`px`/`py`/…,\n * `m`/`mx`/`my`/…) and the CSS longhands. The Styles panel only ever names\n * the longhands — `buildStyleFieldGroups` declares `backgroundColor`, and\n * `ElementStylesForm` reads `paddingTop`…`marginLeft` for the box model —\n * so a stored alias RENDERS but reaches no field: the control shows empty,\n * and clearing the field deletes a key that was never the one painting.\n *\n * The longhand is therefore canonical. Not because the renderer prefers it\n * (it resolves both, so the renderer cannot arbitrate) but because the\n * panel's field names are the only schema the product has.\n *\n * This module is the single table, plus the expansion every read/write\n * seam applies. Nothing REMOVES the alias spelling from the corpus: live\n * documents carry it, the Custom CSS builder is free-solo and its JSON tab\n * takes any key at all, so an alias can arrive at any time. Expanding on\n * read is what makes those documents editable; expanding the colliding\n * keys on write is what makes clearing actually clear.\n */\n\n/**\n * Alias → the CSS longhands it stands for.\n *\n * Ground truth is MUI's own tables, not this file's memory:\n * `@mui/system/styleFunctionSx/defaultSxConfig` gives\n * `bgcolor.cssProperty === 'backgroundColor'`, and `@mui/system/spacing`\n * builds its `CSS_PROPERTIES` table by crossing the two property roots\n * (`m` is margin, `p` is padding) with six direction suffixes — `t` Top,\n * `r` Right, `b` Bottom, `l` Left, `x` Left and Right, `y` Top and Bottom\n * — and then points `paddingX`/`paddingY`/`marginX`/`marginY` at\n * `px`/`py`/`mx`/`my`. `sx-property-aliases.spec.ts` asserts\n * this table against those modules so a MUI upgrade cannot open a spelling\n * we do not know about.\n *\n * Deliberately NOT here:\n *\n * - `p` and `m` map to the CSS shorthands `padding`/`margin` in MUI, but\n *   the panel has no shorthand field — BoxStyler owns four per-side\n *   controls — so they expand to the four longhands. That is exact for the\n *   atomic values {@link isAtomicSxValue} admits and refused for the rest.\n * - `padding`/`margin` themselves. They are real CSS properties whose\n *   value may be a multi-side shorthand, and no panel field owns them\n *   either; rewriting them is a value-parsing problem, not a naming one.\n * - Logical properties (`paddingInline*`, `marginBlock*`, …). MUI lists\n *   them in its spacing set, but each maps to the SAME-named CSS property\n *   — they are not aliases, they are direction-agnostic properties whose\n *   whole point is that they differ from `left`/`right` under RTL.\n */\nexport const SX_PROPERTY_ALIASES: Readonly<\n  Record<string, readonly string[]>\n> = Object.freeze({\n  bgcolor: ['backgroundColor'],\n\n  p: ['paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft'],\n  pt: ['paddingTop'],\n  pr: ['paddingRight'],\n  pb: ['paddingBottom'],\n  pl: ['paddingLeft'],\n  px: ['paddingLeft', 'paddingRight'],\n  py: ['paddingTop', 'paddingBottom'],\n  paddingX: ['paddingLeft', 'paddingRight'],\n  paddingY: ['paddingTop', 'paddingBottom'],\n\n  m: ['marginTop', 'marginRight', 'marginBottom', 'marginLeft'],\n  mt: ['marginTop'],\n  mr: ['marginRight'],\n  mb: ['marginBottom'],\n  ml: ['marginLeft'],\n  mx: ['marginLeft', 'marginRight'],\n  my: ['marginTop', 'marginBottom'],\n  marginX: ['marginLeft', 'marginRight'],\n  marginY: ['marginTop', 'marginBottom'],\n})\n\n/** Every alias spelling, for guards and callers that only need the set. */\nexport const SX_ALIAS_PROPERTIES: readonly string[] = Object.freeze(\n  Object.keys(SX_PROPERTY_ALIASES),\n)\n\n/** Whether `name` is a stray spelling of a canonical style property. */\nexport function isSxAliasProperty(name: string): boolean {\n  return Object.prototype.hasOwnProperty.call(SX_PROPERTY_ALIASES, name)\n}\n\n/** The canonical longhands `name` stands for; empty when it IS canonical. */\nexport function canonicalSxProperties(name: string): readonly string[] {\n  return SX_PROPERTY_ALIASES[name] ?? []\n}\n\n/** Aliases that would write `property` — the keys an edit to it must clear. */\nexport function sxAliasesFor(property: string): string[] {\n  return SX_ALIAS_PROPERTIES.filter((alias) =>\n    SX_PROPERTY_ALIASES[alias].includes(property),\n  )\n}\n\nconst isPlainObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\n/**\n * Whether a value survives being copied onto EACH longhand an alias covers.\n *\n * A number does (`p: 2` → four `padding*: 2`, each through the same MUI\n * spacing transform, so 16px on all four sides either way). A single-token\n * string does (`px: '2rem'`). A multi-token string does NOT: a value like\n * `'10px 20px'` is the CSS shorthand's own per-side syntax, and copying it\n * onto `paddingTop` would silently turn 10px into a two-value declaration\n * CSS drops. Those are left as they are: still rendering, still not editable,\n * but not corrupted either. The panel has no control that could express\n * them anyway.\n *\n * A responsive object (`{xs: 2, md: 4}`) is atomic when every slice is,\n * because the expansion just carries the whole object onto each longhand\n * and MUI resolves it per breakpoint exactly as before.\n */\nexport function isAtomicSxValue(value: unknown): boolean {\n  if (typeof value === 'number') return true\n  if (typeof value === 'string') {\n    const trimmed = value.trim()\n    return trimmed.length > 0 && !/[\\s,]/.test(trimmed)\n  }\n  if (isPlainObject(value)) {\n    const entries = Object.values(value)\n    return entries.length > 0 && entries.every(isAtomicSxValue)\n  }\n  return false\n}\n\n/**\n * Whether an alias key in this record could be expanded — the guard's\n * question, and the identity fast-path's.\n */\nexport function hasExpandableSxAlias(sx: unknown): boolean {\n  if (!isPlainObject(sx)) return false\n  for (const [key, value] of Object.entries(sx)) {\n    if (isSxAliasProperty(key)) {\n      if (SX_PROPERTY_ALIASES[key].length === 1 || isAtomicSxValue(value)) {\n        return true\n      }\n    }\n  }\n  return false\n}\n\n/** Options for {@link expandSxAliases}. */\nexport interface ExpandSxAliasesOptions {\n  /**\n   * Expand only aliases that stand for one of these properties. Used by\n   * the panel's write seam, which must not rewrite keys the author is not\n   * editing. Omitted = expand every expandable alias.\n   */\n  only?: readonly string[]\n  /**\n   * Also expand nested records — the `@scheme dark` slice, breakpoint\n   * media keys, `&:hover` blocks. Off by default so a caller that only\n   * cares about the top level pays for nothing.\n   */\n  deep?: boolean\n}\n\n/**\n * Rewrites alias keys to their canonical longhands, IN PLACE in the key\n * order (AGL-2207).\n *\n * Order is the whole correctness argument. MUI's `styleFunctionSx` walks\n * `sx` with `for…in` and later keys overwrite earlier ones, so\n * `{p: 2, paddingTop: 8}` renders 8px on top and `{paddingTop: 8, p: 2}`\n * renders 2 × the spacing unit. Expanding each alias where it stands —\n * rather than appending the longhands — reproduces both, so the expansion\n * is a pure renaming of what already renders and never a restyle.\n *\n * Returns the input BY IDENTITY when there is nothing to expand, which is\n * every node in a corpus once the presets stop writing aliases, so this\n * sitting on a render path costs one key scan and no allocation.\n */\nexport function expandSxAliases<T>(sx: T, options?: ExpandSxAliasesOptions): T {\n  if (!isPlainObject(sx)) return sx\n  const only = options?.only\n  const deep = options?.deep ?? false\n\n  let changed = false\n  const out: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(sx)) {\n    const canonical = SX_PROPERTY_ALIASES[key]\n    const wanted =\n      canonical &&\n      (!only || canonical.some((name) => only.includes(name))) &&\n      (canonical.length === 1 || isAtomicSxValue(value))\n    if (wanted) {\n      changed = true\n      for (const name of canonical) out[name] = value\n      continue\n    }\n    if (deep && isPlainObject(value)) {\n      const nested = expandSxAliases(value, options)\n      if (nested !== value) changed = true\n      out[key] = nested\n      continue\n    }\n    out[key] = value\n  }\n  return (changed ? out : sx) as T\n}\n\nexport default expandSxAliases\n"],"names":["SX_PROPERTY_ALIASES","Object","freeze","bgcolor","p","pt","pr","pb","pl","px","py","paddingX","paddingY","m","mt","mr","mb","ml","mx","my","marginX","marginY","SX_ALIAS_PROPERTIES","keys","isSxAliasProperty","name","prototype","hasOwnProperty","call","canonicalSxProperties","sxAliasesFor","property","filter","alias","includes","isPlainObject","value","Array","isArray","isAtomicSxValue","trimmed","trim","length","test","entries","values","every","hasExpandableSxAlias","sx","key","expandSxAliases","options","only","deep","changed","out","canonical","wanted","some","nested"],"mappings":"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"}