@multiplatform.one/theme 7.83.1 → 7.83.2

package/dist/cjs/theme/createThemes.native.js

@@ -0,0 +1,1183 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var createThemes_exports = {};
+__export(createThemes_exports, {
+  createThemesBuilder: () => createThemesBuilder,
+  houseComponentThemes: () => houseComponentThemes,
+  houseGrandChildrenThemes: () => houseGrandChildrenThemes,
+  houseTemplates: () => houseTemplates,
+  tintHueNames: () => tintHueNames
+});
+module.exports = __toCommonJS(createThemes_exports);
+var Colors = __toESM(require("@tamagui/colors"));
+var import_theme_builder = require("@tamagui/theme-builder");
+var import_v5 = require("@tamagui/themes/v5");
+var import_colorRules = require("./colorRules.native.js");
+var import_builderOptions = require("./defaults/builderOptions.native.js");
+var import_ramps = require("./ramps.native.js");
+var intentInkFloor = {
+  /** Stored hsla(41, 99%, 30%, 1); 4.54:1 on $color2, dE76 2.54. */
+  warning: "#986801",
+  /** Stored hsla(154, 63%, 31%, 1); 4.53:1 on $color2, dE76 0.82. */
+  success: "#1d8156"
+};
+function withIntentInkFloor(palette, ink) {
+  if (palette.length !== 12) return palette;
+  var stepped = [...palette];
+  stepped[10] = ink;
+  return stepped;
+}
+var lightSurfaceGrouped = {
+  ...import_v5.v5Templates.light_surface1,
+  background: import_theme_builder.PALETTE_BACKGROUND_OFFSET,
+  backgroundHover: import_theme_builder.PALETTE_BACKGROUND_OFFSET + 1,
+  backgroundPress: import_theme_builder.PALETTE_BACKGROUND_OFFSET + 2,
+  backgroundFocus: import_theme_builder.PALETTE_BACKGROUND_OFFSET,
+  backgroundActive: import_theme_builder.PALETTE_BACKGROUND_OFFSET
+};
+var houseTemplates = {
+  ...import_v5.v5Templates,
+  light_surface1: lightSurfaceGrouped
+};
+var houseComponentThemes = {
+  Button: {
+    template: "surface2"
+  },
+  Input: {
+    template: "surface1"
+  },
+  TextArea: {
+    template: "surface1"
+  },
+  Progress: {
+    template: "surface2"
+  },
+  ProgressIndicator: {
+    template: "surface3"
+  },
+  Slider: {
+    template: "surface2"
+  },
+  SliderActive: {
+    template: "surface3"
+  },
+  SliderThumb: {
+    template: "surface1"
+  },
+  Switch: {
+    template: "surface2"
+  },
+  Card: {
+    template: "surface1"
+  },
+  ListItem: {
+    template: "surface1"
+  },
+  SelectTrigger: {
+    template: "surface1"
+  },
+  SelectItem: {
+    template: "surface1"
+  },
+  InputContainerFrame: {
+    template: "surface1"
+  }
+};
+var houseGrandChildrenThemes = {
+  active: {
+    template: "surface3"
+  },
+  alt1: {
+    template: "surface1"
+  },
+  alt2: {
+    template: "surface2"
+  }
+};
+function sanitizeGetTheme(getTheme) {
+  return function (props) {
+    var out = {};
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = Object.entries(getTheme(props))[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var [key, value] = _step.value;
+        if (value != null) out[key] = value;
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+    return out;
+  };
+}
+var tintHueNames = /* @__PURE__ */new Set(["amber", "blue", "bronze", "brown", "crimson", "cyan", "gold", "grass", "gray", "green", "indigo", "lime", "mauve", "mint", "olive", "orange", "pink", "plum", "purple", "red", "sage", "sand", "sky", "slate", "teal", "tomato", "violet", "yellow"]);
+var tintNeutralTextKeys = ["color", "colorHover", "colorPress", "colorFocus", "color11", "color12", "placeholderColor"];
+function neutralizeTintText(themes) {
+  var out = {
+    ...themes
+  };
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = Object.entries(themes)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [name, theme] = _step.value;
+      var parts = name.split("_");
+      if (parts.length < 2) continue;
+      var scheme = parts[0];
+      if (scheme !== "light" && scheme !== "dark") continue;
+      if (!tintHueNames.has(parts[1])) continue;
+      var base = themes[scheme];
+      if (!base) continue;
+      var patched = {
+        ...theme
+      };
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = tintNeutralTextKeys[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var key = _step1.value;
+          if (key in patched && base[key] != null) patched[key] = base[key];
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+      if ("textMuted" in patched) patched.textMuted = (0, import_builderOptions.pickSecondaryInk)(patched, base);
+      out[name] = patched;
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return out;
+}
+var semanticIntentNames = /* @__PURE__ */new Set(["error", "warning", "success"]);
+var entryControlNames = /* @__PURE__ */new Set(["Input", "TextArea"]);
+function neutralizeSemanticEntryText(themes) {
+  var out = {
+    ...themes
+  };
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = Object.entries(themes)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [name, theme] = _step.value;
+      var [scheme, intent, component, ...rest] = name.split("_");
+      if (rest.length > 0 || scheme !== "light" && scheme !== "dark") continue;
+      if (!intent || !semanticIntentNames.has(intent)) continue;
+      var base = themes[scheme];
+      if (!base) continue;
+      if (component === void 0) {
+        if (base.placeholderColor != null) out[name] = {
+          ...theme,
+          placeholderColor: base.placeholderColor
+        };
+        continue;
+      }
+      if (!entryControlNames.has(component)) continue;
+      var neutral = {
+        ...base,
+        ...themes[`${scheme}_${component}`]
+      };
+      var patched = {
+        ...theme
+      };
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = tintNeutralTextKeys[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var key = _step1.value;
+          if (neutral[key] != null) patched[key] = neutral[key];
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+      out[name] = patched;
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return out;
+}
+function luminanceOf(color) {
+  var hex = color ? (0, import_colorRules.normalizeToHex)(color) : null;
+  return hex ? (0, import_colorRules.relativeLuminance)(hex) : null;
+}
+function nearestHoldingStep(preferred, steps, holds) {
+  var preferredLum = luminanceOf(preferred);
+  if (preferredLum === null || holds(preferredLum)) return preferred;
+  var best = preferred;
+  var bestDistance = Number.POSITIVE_INFINITY;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = steps[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var step = _step.value;
+      var lum = luminanceOf(step);
+      if (step === void 0 || lum === null || !holds(lum)) continue;
+      var distance = Math.abs(lum - preferredLum);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        best = step;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return best;
+}
+function holdAccentFloor(themes) {
+  var _loop = function (_i2, _iter2) {
+    var scheme = _iter2[_i2];
+    var base = themes[scheme];
+    if (!(base === null || base === void 0 ? void 0 : base.accentBackground) || !base.accentColor) return "continue";
+    var paper = luminanceOf(base.color1);
+    var ink = luminanceOf(base.color12);
+    var surfaces = [base.color1, base.color2, base.color3, base.color4].map(luminanceOf);
+    if (paper === null || ink === null || surfaces.some(function (lum) {
+      return lum === null;
+    })) return "continue";
+    var steps = Array.from({
+      length: 12
+    }, function (_, index) {
+      return base[`accent${index + 1}`];
+    });
+    var fill = nearestHoldingStep(base.accentBackground, steps.slice(0, 10), function (lum) {
+      return Math.max((0, import_colorRules.contrastRatio)(lum, paper), (0, import_colorRules.contrastRatio)(lum, ink)) >= import_colorRules.aaTextContrastRatio && (0, import_colorRules.contrastRatio)(lum, paper) >= import_colorRules.minContrastRatio;
+    });
+    var accentInk = nearestHoldingStep(base.accentColor, steps, function (lum) {
+      return surfaces.every(function (surface) {
+        return (0, import_colorRules.contrastRatio)(lum, surface) >= import_colorRules.aaTextContrastRatio;
+      });
+    });
+    if (fill === base.accentBackground && accentInk === base.accentColor) return "continue";
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = Object.entries(themes)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var [name, theme] = _step.value;
+        if (name !== scheme && !name.startsWith(`${scheme}_`)) continue;
+        var inheritsFill = theme.accentBackground === base.accentBackground;
+        var inheritsInk = theme.accentColor === base.accentColor;
+        if (!inheritsFill && !inheritsInk) continue;
+        out[name] = {
+          ...theme,
+          ...(inheritsFill ? {
+            accentBackground: fill
+          } : null),
+          ...(inheritsInk ? {
+            accentColor: accentInk
+          } : null)
+        };
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  };
+  var out = {
+    ...themes
+  };
+  for (var _i = 0, _iter = ["light", "dark"]; _i < _iter.length; _i++) _loop(_i, _iter);
+  return out;
+}
+var selectionSurfaceContrastRatio = 1.16;
+var selectionSurfaceScope = /^(light|dark)(_[a-z]+)?$/;
+function holdSelectionSurface(themes) {
+  var out = {
+    ...themes
+  };
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    var _loop = function () {
+      var [scopeName, scope] = _step.value;
+      if (!selectionSurfaceScope.test(scopeName) || /_(accent|active)$/.test(scopeName)) return "continue";
+      var page = luminanceOf(scope.background);
+      var [surface, next, last] = [scope.color4, scope.color5, scope.color6].map(function (color) {
+        return color ? (0, import_colorRules.normalizeToHex)(color) : null;
+      });
+      if (page === null || !surface || !next || !last) return "continue";
+      if ((0, import_colorRules.contrastRatio)((0, import_colorRules.relativeLuminance)(surface), page) >= selectionSurfaceContrastRatio) return "continue";
+      var candidates = [...Array.from({
+        length: 20
+      }, function (_, index) {
+        return mixHex(surface, next, (index + 1) / 20);
+      }), ...Array.from({
+        length: 20
+      }, function (_, index) {
+        return mixHex(next, last, (index + 1) / 20);
+      })];
+      var held = candidates.find(function (candidate) {
+        return (0, import_colorRules.contrastRatio)((0, import_colorRules.relativeLuminance)(candidate), page) >= selectionSurfaceContrastRatio;
+      });
+      if (!held) return "continue";
+      var _iteratorNormalCompletion2 = true,
+        _didIteratorError2 = false,
+        _iteratorError2 = void 0;
+      try {
+        for (var _iterator2 = Object.entries(themes)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion2 = (_step1 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var [name, theme] = _step1.value;
+          if (name !== scopeName && !name.startsWith(`${scopeName}_`)) continue;
+          if (theme.color4 !== scope.color4) continue;
+          out[name] = {
+            ...out[name],
+            color4: held,
+            ...(theme.borderColor === scope.color4 ? {
+              borderColor: held
+            } : null)
+          };
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+    };
+    for (var _iterator = Object.entries(themes)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return out;
+}
+var selectedTintContrastRatio = 1.1;
+var neutralSelectedTintContrastRatio = 1.25;
+var achromaticChannelSpread = 8;
+function isAchromaticRamp(steps) {
+  return steps.every(function (step) {
+    var hex = step ? (0, import_colorRules.normalizeToHex)(step) : null;
+    if (!hex) return false;
+    var channels = [1, 3, 5].map(function (offset) {
+      return Number.parseInt(hex.slice(offset, offset + 2), 16);
+    });
+    return Math.max(...channels) - Math.min(...channels) <= achromaticChannelSpread;
+  });
+}
+function holdSelectedState(themes) {
+  var _loop = function (_i2, _iter2) {
+    var scheme = _iter2[_i2];
+    var base = themes[scheme];
+    if (!(base === null || base === void 0 ? void 0 : base.accentColor)) return "continue";
+    var steps = Array.from({
+      length: 12
+    }, function (_, index) {
+      return base[`accent${index + 1}`];
+    });
+    var paint = selectedPaint(base, steps, base.accentColor);
+    if (paint) out[scheme] = {
+      ...base,
+      ...paint
+    };
+  };
+  var out = {
+    ...themes
+  };
+  for (var _i = 0, _iter = ["light", "dark"]; _i < _iter.length; _i++) _loop(_i, _iter);
+  return out;
+}
+function selectedPaint(scope, steps, accentColor) {
+  var page = luminanceOf(scope.color1);
+  var neutral = luminanceOf(scope.color4);
+  if (page === null || neutral === null) return void 0;
+  var grey = isAchromaticRamp(steps);
+  var offNeutral = grey ? neutralSelectedTintContrastRatio : selectedTintContrastRatio;
+  var tint = nearestHoldingStep(scope.color4, steps, function (lum2) {
+    return (0, import_colorRules.contrastRatio)(lum2, page) >= selectedTintContrastRatio && (0, import_colorRules.contrastRatio)(lum2, neutral) >= offNeutral;
+  });
+  var tintLum = luminanceOf(tint);
+  if (tint === scope.color4 || tintLum === null) return void 0;
+  if (grey) {
+    var strongest = tint;
+    var strongestRatio = 0;
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = steps[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var step = _step.value;
+        var lum = luminanceOf(step);
+        if (step === void 0 || lum === null) continue;
+        var ratio = (0, import_colorRules.contrastRatio)(lum, tintLum);
+        if (ratio > strongestRatio) {
+          strongest = step;
+          strongestRatio = ratio;
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+    if (strongestRatio >= import_colorRules.aaTextContrastRatio) return {
+      selectedBackground: tint,
+      selectedColor: strongest
+    };
+  }
+  var ink = nearestHoldingStep(accentColor, steps, function (lum2) {
+    return (0, import_colorRules.contrastRatio)(lum2, tintLum) >= import_colorRules.aaTextContrastRatio;
+  });
+  return {
+    selectedBackground: tint,
+    selectedColor: ink
+  };
+}
+var switchStateContrastRatio = 1.5;
+var switchRaisedAlphas = [0.16, 0.2, 0.24, 0.28, 0.32, 0.36, 0.4];
+var switchRaisedAlphaStep = 0.04;
+function raisedGrounds(themes, scheme) {
+  var _themes_scheme;
+  if (scheme === "light") return [];
+  var hues = Object.entries(themes).filter(function (param) {
+    var [name] = param;
+    return new RegExp(`^${scheme}_[a-z]+$`).test(name);
+  }).filter(function (param) {
+    var [name] = param;
+    return !/_(accent|active)$/.test(name);
+  });
+  return [(_themes_scheme = themes[scheme]) === null || _themes_scheme === void 0 ? void 0 : _themes_scheme.color4, ...hues.map(function (param) {
+    var [, theme] = param;
+    return theme.color4;
+  })].filter(function (color) {
+    return typeof color === "string";
+  });
+}
+function holdSwitchTrack(themes) {
+  var out = {
+    ...themes
+  };
+  for (var _i = 0, _iter = ["light", "dark"]; _i < _iter.length; _i++) {
+    var scheme = _iter[_i];
+    var base = themes[scheme];
+    if (!base) continue;
+    var paint = switchTrackPaint(base, base.accentBackground, base.background, raisedGrounds(themes, scheme));
+    if (paint) out[scheme] = {
+      ...base,
+      ...paint
+    };
+  }
+  return out;
+}
+function switchTrackPaint(base, onFill, ground) {
+  var raised = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : [];
+  var _ref, _inBand_find;
+  var on = luminanceOf(onFill);
+  if (!ground || on === null) return void 0;
+  var alpha = import_colorRules.switchOffFillAlpha[(0, import_colorRules.isLightGround)(ground) ? "light" : "dark"];
+  var target = (0, import_colorRules.systemFillLuminance)(ground, alpha);
+  if (target === null) return void 0;
+  var raisedLums = raised.map(function (color) {
+    return luminanceOf(color);
+  }).filter(function (lum) {
+    return lum !== null;
+  });
+  var greys = Array.from({
+    length: 12
+  }, function (_, index) {
+    return index + 1;
+  }).map(function (step) {
+    return {
+      color: base[`gray${step}`],
+      lum: luminanceOf(base[`gray${step}`]),
+      hover: base[`gray${Math.max(step - 1, 1)}`],
+      press: base[`gray${Math.min(step + 1, 12)}`]
+    };
+  }).filter(function (entry) {
+    return entry.lum !== null;
+  });
+  var fills = raised[0] ? switchRaisedAlphas.flatMap(function (fillAlpha) {
+    var color = (0, import_colorRules.systemFillHex)(raised[0], fillAlpha);
+    var hover = (0, import_colorRules.systemFillHex)(raised[0], fillAlpha - switchRaisedAlphaStep);
+    var press = (0, import_colorRules.systemFillHex)(raised[0], fillAlpha + switchRaisedAlphaStep);
+    var lum = luminanceOf(color !== null && color !== void 0 ? color : void 0);
+    return color && hover && press && lum !== null ? [{
+      color,
+      lum,
+      hover,
+      press
+    }] : [];
+  }) : [];
+  var byTarget = function byTarget2(a, b) {
+    return Math.abs(a.lum - target) - Math.abs(b.lum - target);
+  };
+  var steps = [...greys].sort(byTarget);
+  var inBand = [...greys, ...fills].filter(function (entry) {
+    return (0, import_colorRules.inSwitchOffBand)(entry.color, ground);
+  }).filter(function (entry) {
+    return raisedLums.every(function (lum) {
+      return (0, import_colorRules.contrastRatio)(entry.lum, lum) >= import_colorRules.plateContrastRatio;
+    });
+  }).sort(byTarget);
+  var pick = (_ref = (_inBand_find = inBand.find(function (entry) {
+    return (0, import_colorRules.contrastRatio)(entry.lum, on) >= switchStateContrastRatio;
+  })) !== null && _inBand_find !== void 0 ? _inBand_find : inBand[0]) !== null && _ref !== void 0 ? _ref : steps[0];
+  if (!pick) return void 0;
+  return {
+    switchTrackOff: pick.color,
+    switchTrackOffHover: pick.hover,
+    switchTrackOffPress: pick.press
+  };
+}
+var syntaxInkHues = ["purple", "green", "blue", "orange", "red"];
+function mixHex(from, to, share) {
+  var channel = function channel2(offset) {
+    return Math.round(Number.parseInt(from.slice(offset, offset + 2), 16) * (1 - share) + Number.parseInt(to.slice(offset, offset + 2), 16) * share).toString(16).padStart(2, "0");
+  };
+  return `#${channel(1)}${channel(3)}${channel(5)}`;
+}
+function holdSyntaxFloor(themes) {
+  var out = {
+    ...themes
+  };
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = Object.entries(themes)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [name, theme] = _step.value;
+      var surface = luminanceOf(theme.color3);
+      if (surface === null) continue;
+      var ink = {};
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = syntaxInkHues[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var hue = _step1.value;
+          var from = theme[`${hue}11`] ? (0, import_colorRules.normalizeToHex)(theme[`${hue}11`]) : null;
+          var to = theme[`${hue}12`] ? (0, import_colorRules.normalizeToHex)(theme[`${hue}12`]) : null;
+          var wash = luminanceOf(theme[`${hue}3`]);
+          if (!from || !to || wash === null) continue;
+          for (var step = 0; step <= 20; step++) {
+            var candidate = mixHex(from, to, step / 20);
+            var lum = (0, import_colorRules.relativeLuminance)(candidate);
+            if ((0, import_colorRules.contrastRatio)(lum, surface) >= import_colorRules.aaTextContrastRatio && (0, import_colorRules.contrastRatio)(lum, wash) >= import_colorRules.aaTextContrastRatio) {
+              ink[`syntax${hue[0].toUpperCase()}${hue.slice(1)}`] = candidate;
+              break;
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+      if (Object.keys(ink).length > 0) out[name] = {
+        ...theme,
+        ...ink
+      };
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return out;
+}
+var namedInkHues = import_ramps.themeRampHues;
+function holdNamedInkFloor(themes) {
+  var out = {
+    ...themes
+  };
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = Object.entries(themes)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [name, theme] = _step.value;
+      var surfaces = [luminanceOf(theme.background), luminanceOf(theme.color3)];
+      if (surfaces.some(function (surface) {
+        return surface === null;
+      })) continue;
+      var ink = {};
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = namedInkHues[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var _loop = function (step2) {
+            var candidate = mixHex(from, to, step2 / 20);
+            var lum = (0, import_colorRules.relativeLuminance)(candidate);
+            if (surfaces.every(function (surface) {
+              return (0, import_colorRules.contrastRatio)(lum, surface) >= import_colorRules.aaTextContrastRatio;
+            })) {
+              if (step2 > 0) ink[`${hue}11`] = candidate;
+              return "break";
+            }
+          };
+          var hue = _step1.value;
+          var from = theme[`${hue}11`] ? (0, import_colorRules.normalizeToHex)(theme[`${hue}11`]) : null;
+          var to = theme[`${hue}12`] ? (0, import_colorRules.normalizeToHex)(theme[`${hue}12`]) : null;
+          if (!from || !to) continue;
+          for (var step = 0; step <= 20; step++) {
+            var _ret = _loop(step);
+            if (_ret === "break") break;
+          }
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+      if (Object.keys(ink).length > 0) out[name] = {
+        ...theme,
+        ...ink
+      };
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return out;
+}
+function walkToHoldingInk(step11, step12, holds) {
+  var from = (0, import_colorRules.normalizeToHex)(step11);
+  var to = (0, import_colorRules.normalizeToHex)(step12);
+  if (!from || !to) return null;
+  if (holds((0, import_colorRules.relativeLuminance)(from))) return step11;
+  for (var step = 1; step <= 20; step++) {
+    var candidate = mixHex(from, to, step / 20);
+    if (holds((0, import_colorRules.relativeLuminance)(candidate))) return candidate;
+  }
+  return null;
+}
+function holdFillLabel(preferred, steps, labels, paper) {
+  var preferredLum = luminanceOf(preferred);
+  if (preferredLum === null) return void 0;
+  var labelOn = function labelOn2(step2) {
+    return labels.find(function (label2) {
+      var lum2 = luminanceOf(label2);
+      var stepLum = luminanceOf(step2);
+      return lum2 !== null && stepLum !== null && (0, import_colorRules.contrastRatio)(lum2, stepLum) >= import_colorRules.aaTextContrastRatio && Math.abs((0, import_colorRules.apcaContrast)(label2, step2)) >= import_colorRules.fillLabelLc;
+    });
+  };
+  var best;
+  var bestDistance = Number.POSITIVE_INFINITY;
+  for (var _i = 0, _iter = [preferred, ...steps]; _i < _iter.length; _i++) {
+    var step = _iter[_i];
+    var lum = luminanceOf(step);
+    if (step === void 0 || lum === null || (0, import_colorRules.contrastRatio)(lum, paper) < import_colorRules.minContrastRatio) continue;
+    var label = labelOn(step);
+    var distance = Math.abs(lum - preferredLum);
+    if (label && distance < bestDistance) {
+      bestDistance = distance;
+      best = {
+        fill: step,
+        label
+      };
+    }
+  }
+  return best;
+}
+function holdColorThemeAccent(themes) {
+  var _loop = function (_i2, _iter2) {
+    var scheme = _iter2[_i2];
+    var base = themes[scheme];
+    if (!base) return "continue";
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      var _loop2 = function () {
+        var hue = _step.value;
+        var _ref, _walkToHoldingInk, _ref1;
+        var scopeName = `${scheme}_${hue}`;
+        var scope = themes[scopeName];
+        var ramp = Array.from({
+          length: 12
+        }, function (_, index) {
+          return base[`${hue}${index + 1}`];
+        });
+        if (!scope || ramp.some(function (step) {
+          return !step;
+        })) return "continue";
+        var paper = luminanceOf(scope.color1);
+        var ink = luminanceOf(scope.color12);
+        var surfaces = [scope.color1, scope.color2, scope.color3, scope.color4].map(luminanceOf);
+        if (paper === null || ink === null || surfaces.some(function (lum) {
+          return lum === null;
+        })) return "continue";
+        var labels = [scope.color1, scope.color12].sort(function (a, b) {
+          return luminanceOf(b) - luminanceOf(a);
+        });
+        var solid = holdFillLabel(ramp[8], ramp.slice(0, 11), labels, paper);
+        var holdsInk = function holdsInk2(lum) {
+          return surfaces.every(function (surface) {
+            return (0, import_colorRules.contrastRatio)(lum, surface) >= import_colorRules.aaTextContrastRatio;
+          });
+        };
+        var fill = (_ref = solid === null || solid === void 0 ? void 0 : solid.fill) !== null && _ref !== void 0 ? _ref : nearestHoldingStep(ramp[8], ramp.slice(0, 11), function (lum) {
+          return Math.max((0, import_colorRules.contrastRatio)(lum, paper), (0, import_colorRules.contrastRatio)(lum, ink)) >= import_colorRules.aaTextContrastRatio && (0, import_colorRules.contrastRatio)(lum, paper) >= import_colorRules.minContrastRatio;
+        });
+        var accentInk = (_walkToHoldingInk = walkToHoldingInk(ramp[10], ramp[11], holdsInk)) !== null && _walkToHoldingInk !== void 0 ? _walkToHoldingInk : nearestHoldingStep(ramp[10], ramp, holdsInk);
+        var fillStep = ramp.indexOf(fill);
+        var fillHover = ramp[Math.min(fillStep + 1, ramp.length - 1)];
+        var onFill = (_ref1 = solid === null || solid === void 0 ? void 0 : solid.label) !== null && _ref1 !== void 0 ? _ref1 : (0, import_colorRules.holdInkFloor)(fill, (0, import_colorRules.pickReadableForeground)(fill, scope.color1, scope.color12));
+        var accent = {
+          accentBackground: fill,
+          accentColor: accentInk,
+          ...selectedPaint(scope, ramp, accentInk)
+        };
+        var rootOn = luminanceOf(base.switchTrackOff);
+        var fillLum = luminanceOf(fill);
+        var rootHolds = rootOn === null || fillLum === null || (0, import_colorRules.contrastRatio)(rootOn, fillLum) >= switchStateContrastRatio;
+        var track = rootHolds ? void 0 : switchTrackPaint(base, fill, scope.background, (0, import_colorRules.isLightGround)(scope.background) ? [] : [scope.color4]);
+        var _iteratorNormalCompletion2 = true,
+          _didIteratorError2 = false,
+          _iteratorError2 = void 0;
+        try {
+          var _loop3 = function () {
+            var [name, theme] = _step1.value;
+            if (name === scopeName) {
+              out[name] = {
+                ...theme,
+                ...accent,
+                ...track
+              };
+            } else if (name.startsWith(`${scopeName}_`)) {
+              var owned = Object.keys(accent).filter(function (key) {
+                return key in theme;
+              });
+              if (owned.length > 0) {
+                out[name] = {
+                  ...theme,
+                  ...Object.fromEntries(owned.map(function (key) {
+                    return [key, accent[key]];
+                  }))
+                };
+              }
+            }
+          };
+          for (var _iterator2 = Object.entries(themes)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion2 = (_step1 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) _loop3();
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+              _iterator2.return();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
+        }
+        out[`${scopeName}_accent`] = {
+          background: fill,
+          backgroundHover: fillHover,
+          backgroundPress: fillHover,
+          backgroundFocus: fillHover,
+          backgroundActive: fill,
+          borderColor: fill,
+          borderColorHover: fillHover,
+          borderColorFocus: fillHover,
+          borderColorPress: fillHover,
+          color: onFill,
+          colorHover: onFill,
+          colorPress: onFill,
+          colorFocus: onFill,
+          placeholderColor: onFill,
+          boundaryColor: onFill,
+          outlineColor: onFill,
+          color10: onFill,
+          color11: onFill,
+          color12: onFill,
+          textMuted: onFill,
+          accentBackground: onFill,
+          accentColor: onFill
+        };
+      };
+      for (var _iterator = childrenHues[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop2();
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  };
+  var out = {
+    ...themes
+  };
+  for (var _i = 0, _iter = ["light", "dark"]; _i < _iter.length; _i++) _loop(_i, _iter);
+  return out;
+}
+var defaultLightShadows = {
+  shadow1: "rgba(0,0,0,0.04)",
+  shadow2: "rgba(0,0,0,0.08)",
+  shadow3: "rgba(0,0,0,0.12)",
+  shadow4: "rgba(0,0,0,0.22)",
+  shadow5: "rgba(0,0,0,0.33)",
+  shadow6: "rgba(0,0,0,0.44)"
+};
+var defaultDarkShadows = {
+  shadow1: "rgba(0,0,0,0.15)",
+  shadow2: "rgba(0,0,0,0.23)",
+  shadow3: "rgba(0,0,0,0.33)",
+  shadow4: "rgba(0,0,0,0.45)",
+  shadow5: "rgba(0,0,0,0.65)",
+  shadow6: "rgba(0,0,0,0.8)"
+};
+var childrenHues = ["blue", "red", "green", "yellow", "orange", "pink", "purple", "gray"];
+function holdFocusRingAccent(themes) {
+  var _loop = function (_i2, _iter2) {
+    var scheme = _iter2[_i2];
+    var _themes_;
+    var base = themes[scheme];
+    if (!base) return "continue";
+    var grounds = [base.color1, base.color2].map(luminanceOf);
+    if (grounds.some(function (lum) {
+      return lum === null;
+    })) return "continue";
+    var holds = function holds2(color) {
+      var lum = luminanceOf(color);
+      return lum !== null && isChromatic(color) && grounds.every(function (ground) {
+        return (0, import_colorRules.contrastRatio)(lum, ground) >= import_colorRules.minContrastRatio;
+      });
+    };
+    var rootRing = [base.accentColor, (_themes_ = themes[`${scheme}_blue`]) === null || _themes_ === void 0 ? void 0 : _themes_.accentColor].find(holds);
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = Object.entries(themes)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var [name, theme] = _step.value;
+        var _parts_;
+        var _themes_1;
+        if (name !== scheme && !name.startsWith(`${scheme}_`)) continue;
+        if (theme.outlineColor === void 0) continue;
+        var parts = name.split("_");
+        if (parts.includes("accent")) continue;
+        var hue = childrenHues.includes((_parts_ = parts[1]) !== null && _parts_ !== void 0 ? _parts_ : "") ? parts[1] : void 0;
+        var scopeInk = hue ? (_themes_1 = themes[`${scheme}_${hue}`]) === null || _themes_1 === void 0 ? void 0 : _themes_1.accentColor : void 0;
+        var ring = holds(scopeInk) ? scopeInk : rootRing;
+        if (!ring || ring === theme.outlineColor) continue;
+        out[name] = {
+          ...theme,
+          outlineColor: ring
+        };
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  };
+  var out = {
+    ...themes
+  };
+  for (var _i = 0, _iter = ["light", "dark"]; _i < _iter.length; _i++) _loop(_i, _iter);
+  return out;
+}
+function isChromatic(color) {
+  var hex = color ? (0, import_colorRules.normalizeToHex)(color) : null;
+  if (!hex) return false;
+  var channels = [1, 3, 5].map(function (index) {
+    return Number.parseInt(hex.slice(index, index + 2), 16);
+  });
+  return Math.max(...channels) - Math.min(...channels) >= 24;
+}
+function createThemesBuilder(baseTheme, accentTheme, options) {
+  var _ref, _ref1;
+  var _baseTheme_lightShadows, _baseTheme_darkShadows;
+  var getTheme = (options === null || options === void 0 ? void 0 : options.getTheme) ? sanitizeGetTheme(options.getTheme) : void 0;
+  var base = {
+    palette: {
+      dark: baseTheme.darkPalette,
+      light: baseTheme.lightPalette
+    },
+    extra: {
+      light: {
+        ...Object.assign({}, ...Object.values(import_v5.defaultChildrenThemes).map(function (theme) {
+          return theme.light;
+        })),
+        ...baseTheme.lightShadows,
+        shadowColor: ((_baseTheme_lightShadows = baseTheme.lightShadows) === null || _baseTheme_lightShadows === void 0 ? void 0 : _baseTheme_lightShadows.shadow3) || defaultLightShadows.shadow3
+      },
+      dark: {
+        ...Object.assign({}, ...Object.values(import_v5.defaultChildrenThemes).map(function (theme) {
+          return theme.dark;
+        })),
+        ...baseTheme.darkShadows,
+        shadowColor: ((_baseTheme_darkShadows = baseTheme.darkShadows) === null || _baseTheme_darkShadows === void 0 ? void 0 : _baseTheme_darkShadows.shadow3) || defaultDarkShadows.shadow3
+      }
+    }
+  };
+  var childrenThemes = {
+    ...Object.fromEntries(childrenHues.map(function (name) {
+      var {
+        light,
+        dark
+      } = import_v5.defaultChildrenThemes[name];
+      return [name, {
+        palette: {
+          light: Object.values(light),
+          dark: Object.values(dark)
+        }
+      }];
+    })),
+    warning: {
+      palette: {
+        dark: Object.values(Colors.yellowDark),
+        light: withIntentInkFloor(Object.values(Colors.yellow), intentInkFloor.warning)
+      }
+    },
+    error: {
+      palette: {
+        dark: Object.values(Colors.redDark),
+        light: Object.values(Colors.red)
+      }
+    },
+    success: {
+      palette: {
+        dark: Object.values(Colors.greenDark),
+        light: withIntentInkFloor(Object.values(Colors.green), intentInkFloor.success)
+      }
+    }
+  };
+  var createThemesProps = {
+    templates: houseTemplates,
+    componentThemes: (_ref = options === null || options === void 0 ? void 0 : options.componentThemes) !== null && _ref !== void 0 ? _ref : houseComponentThemes,
+    grandChildrenThemes: (_ref1 = options === null || options === void 0 ? void 0 : options.grandChildrenThemes) !== null && _ref1 !== void 0 ? _ref1 : houseGrandChildrenThemes,
+    base,
+    childrenThemes,
+    accent: {
+      palette: {
+        dark: accentTheme.darkPalette,
+        light: accentTheme.lightPalette
+      }
+    }
+  };
+  if (getTheme) {
+    createThemesProps.getTheme = getTheme;
+  }
+  var initialTheme = (0, import_theme_builder.createThemes)(createThemesProps);
+  var themes = holdFocusRingAccent(holdColorThemeAccent(holdSwitchTrack(holdSyntaxFloor(holdNamedInkFloor(holdSelectedState(holdAccentFloor(holdSelectionSurface(neutralizeSemanticEntryText(neutralizeTintText(initialTheme))))))))));
+  return {
+    themes() {
+      return themes;
+    },
+    addTheme(name, theme) {
+      var _ref2, _ref12;
+      var addThemeProps = {
+        templates: houseTemplates,
+        componentThemes: (_ref2 = options === null || options === void 0 ? void 0 : options.componentThemes) !== null && _ref2 !== void 0 ? _ref2 : houseComponentThemes,
+        grandChildrenThemes: (_ref12 = options === null || options === void 0 ? void 0 : options.grandChildrenThemes) !== null && _ref12 !== void 0 ? _ref12 : houseGrandChildrenThemes,
+        base,
+        childrenThemes,
+        accent: {
+          palette: {
+            dark: theme.darkPalette,
+            light: theme.lightPalette
+          }
+        }
+      };
+      if (getTheme) {
+        addThemeProps.getTheme = getTheme;
+      }
+      var createdTheme = (0, import_theme_builder.createThemes)(addThemeProps);
+      return {
+        [`dark_${name}`]: createdTheme.dark_accent,
+        [`light_${name}`]: createdTheme.light_accent
+      };
+    }
+  };
+}
+//# sourceMappingURL=createThemes.native.js.map