Add m-esr52 at 52.6.0

1 files changed, 3428 insertions, 0 deletions

diff --git a/layout/style/nsCSSProps.cpp b/layout/style/nsCSSProps.cpp
new file mode 100644
index 0000000000..ec28d06f8f
--- /dev/null
+++ b/layout/style/nsCSSProps.cpp
@@ -0,0 +1,3428 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * methods for dealing with CSS properties and tables of the keyword
+ * values they accept
+ */
+
+#include "mozilla/ArrayUtils.h"
+
+#include "nsCSSProps.h"
+#include "nsCSSKeywords.h"
+#include "nsLayoutUtils.h"
+#include "nsStyleConsts.h"
+#include "nsIWidget.h"
+#include "nsThemeConstants.h"  // For system widget appearance types
+
+#include "mozilla/dom/AnimationEffectReadOnlyBinding.h" // for PlaybackDirection
+#include "mozilla/LookAndFeel.h" // for system colors
+
+#include "nsString.h"
+#include "nsStaticAtom.h"
+#include "nsStaticNameTable.h"
+
+#include "mozilla/Preferences.h"
+
+using namespace mozilla;
+
+typedef nsCSSProps::KTableEntry KTableEntry;
+
+// By wrapping internal-only properties in this macro, we are not
+// exposing them in the CSSOM. Since currently it is not necessary to
+// allow accessing them in that way, it is easier and cheaper to just
+// do this rather than exposing them conditionally.
+#define CSS_PROP(name_, id_, method_, flags_, pref_, ...) \
+  static_assert(!((flags_) & CSS_PROPERTY_ENABLED_MASK) || pref_[0], \
+                "Internal-only property '" #name_ "' should be wrapped in " \
+                "#ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL");
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#define CSS_PROP_LIST_EXCLUDE_INTERNAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_EXCLUDE_INTERNAL
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP
+
+#define CSS_PROP(name_, id_, method_, flags_, pref_, ...) \
+  static_assert(!((flags_) & CSS_PROPERTY_ENABLED_IN_CHROME) || \
+                ((flags_) & CSS_PROPERTY_ENABLED_IN_UA_SHEETS), \
+                "Property '" #name_ "' is enabled in chrome, so it should " \
+                "also be enabled in UA sheets");
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP
+
+// required to make the symbol external, so that TestCSSPropertyLookup.cpp can link with it
+extern const char* const kCSSRawProperties[];
+
+// define an array of all CSS properties
+const char* const kCSSRawProperties[eCSSProperty_COUNT_with_aliases] = {
+#define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_, kwtable_, \
+                 stylestruct_, stylestructoffset_, animtype_)                 \
+  #name_,
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP
+#define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) #name_,
+#include "nsCSSPropList.h"
+#undef CSS_PROP_SHORTHAND
+#define CSS_PROP_ALIAS(aliasname_, id_, method_, pref_) #aliasname_,
+#include "nsCSSPropAliasList.h"
+#undef CSS_PROP_ALIAS
+};
+
+using namespace mozilla;
+
+static int32_t gPropertyTableRefCount;
+static nsStaticCaseInsensitiveNameTable* gPropertyTable;
+static nsStaticCaseInsensitiveNameTable* gFontDescTable;
+static nsStaticCaseInsensitiveNameTable* gCounterDescTable;
+static nsStaticCaseInsensitiveNameTable* gPredefinedCounterStyleTable;
+static nsDataHashtable<nsCStringHashKey,nsCSSPropertyID>* gPropertyIDLNameTable;
+
+/* static */ nsCSSPropertyID *
+  nsCSSProps::gShorthandsContainingTable[eCSSProperty_COUNT_no_shorthands];
+/* static */ nsCSSPropertyID* nsCSSProps::gShorthandsContainingPool = nullptr;
+
+static const char* const kCSSRawFontDescs[] = {
+#define CSS_FONT_DESC(name_, method_) #name_,
+#include "nsCSSFontDescList.h"
+#undef CSS_FONT_DESC
+};
+
+static const char* const kCSSRawCounterDescs[] = {
+#define CSS_COUNTER_DESC(name_, method_) #name_,
+#include "nsCSSCounterDescList.h"
+#undef CSS_COUNTER_DESC
+};
+
+static const char* const kCSSRawPredefinedCounterStyles[] = {
+  "none",
+  // 6 Simple Predefined Counter Styles
+  // 6.1 Numeric
+  "decimal", "decimal-leading-zero", "arabic-indic", "armenian",
+  "upper-armenian", "lower-armenian", "bengali", "cambodian", "khmer",
+  "cjk-decimal", "devanagari", "georgian", "gujarati", "gurmukhi", "hebrew",
+  "kannada", "lao", "malayalam", "mongolian", "myanmar", "oriya", "persian",
+  "lower-roman", "upper-roman", "tamil", "telugu", "thai", "tibetan",
+  // 6.2 Alphabetic
+  "lower-alpha", "lower-latin", "upper-alpha", "upper-latin",
+  "cjk-earthly-branch", "cjk-heavenly-stem", "lower-greek",
+  "hiragana", "hiragana-iroha", "katakana", "katakana-iroha",
+  // 6.3 Symbolic
+  "disc", "circle", "square", "disclosure-open", "disclosure-closed",
+  // 7 Complex Predefined Counter Styles
+  // 7.1 Longhand East Asian Counter Styles
+  // 7.1.1 Japanese
+  "japanese-informal", "japanese-formal",
+  // 7.1.2 Korean
+  "korean-hangul-formal", "korean-hanja-informal", "korean-hanja-formal",
+  // 7.1.3 Chinese
+  "simp-chinese-informal", "simp-chinese-formal",
+  "trad-chinese-informal", "trad-chinese-formal", "cjk-ideographic",
+  // 7.2 Ethiopic Numeric Counter Style
+  "ethiopic-numeric"
+};
+
+struct PropertyAndCount {
+  nsCSSPropertyID property;
+  uint32_t count;
+};
+
+static int
+SortPropertyAndCount(const void* s1, const void* s2, void *closure)
+{
+  const PropertyAndCount *pc1 = static_cast<const PropertyAndCount*>(s1);
+  const PropertyAndCount *pc2 = static_cast<const PropertyAndCount*>(s2);
+  // Primary sort by count (lowest to highest)
+  if (pc1->count != pc2->count)
+    return pc1->count - pc2->count;
+  // Secondary sort by property index (highest to lowest)
+  return pc2->property - pc1->property;
+}
+
+// We need eCSSAliasCount so we can make gAliases nonzero size when there
+// are no aliases.
+enum {
+  eCSSAliasCount = eCSSProperty_COUNT_with_aliases - eCSSProperty_COUNT
+};
+
+// The names are in kCSSRawProperties.
+static nsCSSPropertyID gAliases[eCSSAliasCount != 0 ? eCSSAliasCount : 1] = {
+#define CSS_PROP_ALIAS(aliasname_, propid_, aliasmethod_, pref_)  \
+  eCSSProperty_##propid_ ,
+#include "nsCSSPropAliasList.h"
+#undef CSS_PROP_ALIAS
+};
+
+nsStaticCaseInsensitiveNameTable*
+CreateStaticTable(const char* const aRawTable[], int32_t aLength)
+{
+  auto table = new nsStaticCaseInsensitiveNameTable(aRawTable, aLength);
+#ifdef DEBUG
+  // Partially verify the entries.
+  for (int32_t index = 0; index < aLength; ++index) {
+    nsAutoCString temp(aRawTable[index]);
+    MOZ_ASSERT(-1 == temp.FindChar('_'),
+               "underscore char in case insensitive name table");
+  }
+#endif
+  return table;
+}
+
+void
+nsCSSProps::AddRefTable(void)
+{
+  if (0 == gPropertyTableRefCount++) {
+    MOZ_ASSERT(!gPropertyTable, "pre existing array!");
+    MOZ_ASSERT(!gFontDescTable, "pre existing array!");
+    MOZ_ASSERT(!gCounterDescTable, "pre existing array!");
+    MOZ_ASSERT(!gPredefinedCounterStyleTable, "pre existing array!");
+    MOZ_ASSERT(!gPropertyIDLNameTable, "pre existing array!");
+
+    gPropertyTable = CreateStaticTable(
+        kCSSRawProperties, eCSSProperty_COUNT_with_aliases);
+    gFontDescTable = CreateStaticTable(kCSSRawFontDescs, eCSSFontDesc_COUNT);
+    gCounterDescTable = CreateStaticTable(
+        kCSSRawCounterDescs, eCSSCounterDesc_COUNT);
+    gPredefinedCounterStyleTable = CreateStaticTable(
+        kCSSRawPredefinedCounterStyles,
+        ArrayLength(kCSSRawPredefinedCounterStyles));
+
+    gPropertyIDLNameTable = new nsDataHashtable<nsCStringHashKey,nsCSSPropertyID>;
+    for (nsCSSPropertyID p = nsCSSPropertyID(0);
+         size_t(p) < ArrayLength(kIDLNameTable);
+         p = nsCSSPropertyID(p + 1)) {
+      if (kIDLNameTable[p]) {
+        gPropertyIDLNameTable->Put(nsDependentCString(kIDLNameTable[p]), p);
+      }
+    }
+
+    BuildShorthandsContainingTable();
+
+    static bool prefObserversInited = false;
+    if (!prefObserversInited) {
+      prefObserversInited = true;
+      
+      #define OBSERVE_PROP(pref_, id_)                                        \
+        if (pref_[0]) {                                                       \
+          Preferences::AddBoolVarCache(&gPropertyEnabled[id_],                \
+                                       pref_);                                \
+        }
+
+      #define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_,     \
+                       kwtable_, stylestruct_, stylestructoffset_, animtype_) \
+        OBSERVE_PROP(pref_, eCSSProperty_##id_)
+      #define CSS_PROP_LIST_INCLUDE_LOGICAL
+      #include "nsCSSPropList.h"
+      #undef CSS_PROP_LIST_INCLUDE_LOGICAL
+      #undef CSS_PROP
+
+      #define  CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) \
+        OBSERVE_PROP(pref_, eCSSProperty_##id_)
+      #include "nsCSSPropList.h"
+      #undef CSS_PROP_SHORTHAND
+
+      #define CSS_PROP_ALIAS(aliasname_, propid_, aliasmethod_, pref_)    \
+        OBSERVE_PROP(pref_, eCSSPropertyAlias_##aliasmethod_)
+      #include "nsCSSPropAliasList.h"
+      #undef CSS_PROP_ALIAS
+
+      #undef OBSERVE_PROP
+    }
+
+#ifdef DEBUG
+    {
+      // Assert that if CSS_PROPERTY_ENABLED_IN_UA_SHEETS or
+      // CSS_PROPERTY_ENABLED_IN_CHROME is used on a shorthand property
+      // that all of its component longhands also have the flag.
+      static uint32_t flagsToCheck[] = {
+        CSS_PROPERTY_ENABLED_IN_UA_SHEETS,
+        CSS_PROPERTY_ENABLED_IN_CHROME
+      };
+      for (nsCSSPropertyID shorthand = eCSSProperty_COUNT_no_shorthands;
+           shorthand < eCSSProperty_COUNT;
+           shorthand = nsCSSPropertyID(shorthand + 1)) {
+        for (size_t i = 0; i < ArrayLength(flagsToCheck); i++) {
+          uint32_t flag = flagsToCheck[i];
+          if (!nsCSSProps::PropHasFlags(shorthand, flag)) {
+            continue;
+          }
+          for (const nsCSSPropertyID* p =
+                 nsCSSProps::SubpropertyEntryFor(shorthand);
+               *p != eCSSProperty_UNKNOWN;
+               ++p) {
+            MOZ_ASSERT(nsCSSProps::PropHasFlags(*p, flag),
+                       "all subproperties of a property with a "
+                       "CSS_PROPERTY_ENABLED_* flag must also have "
+                       "the flag");
+          }
+        }
+      }
+
+      // Assert that CSS_PROPERTY_INTERNAL is used on properties in
+      // #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL sections of nsCSSPropList.h
+      // and on no others.
+      static nsCSSPropertyID nonInternalProperties[] = {
+        #define CSS_PROP(name_, id_, ...)           eCSSProperty_##id_,
+        #define CSS_PROP_SHORTHAND(name_, id_, ...) eCSSProperty_##id_,
+        #define CSS_PROP_LIST_INCLUDE_LOGICAL
+        #define CSS_PROP_LIST_EXCLUDE_INTERNAL
+        #include "nsCSSPropList.h"
+        #undef CSS_PROP_LIST_EXCLUDE_INTERNAL
+        #undef CSS_PROP_LIST_INCLUDE_LOGICAL
+        #undef CSS_PROP_SHORTHAND
+        #undef CSS_PROP
+      };
+      MOZ_ASSERT(ArrayLength(nonInternalProperties) <= eCSSProperty_COUNT);
+
+      bool found[eCSSProperty_COUNT];
+      PodArrayZero(found);
+      for (nsCSSPropertyID p : nonInternalProperties) {
+        MOZ_ASSERT(!nsCSSProps::PropHasFlags(p, CSS_PROPERTY_INTERNAL),
+                   "properties defined outside of #ifndef "
+                   "CSS_PROP_LIST_EXCLUDE_INTERNAL sections must not have "
+                   "the CSS_PROPERTY_INTERNAL flag");
+        found[p] = true;
+      }
+
+      for (size_t i = 0; i < ArrayLength(found); ++i) {
+        if (!found[i]) {
+          auto p = static_cast<nsCSSPropertyID>(i);
+          MOZ_ASSERT(nsCSSProps::PropHasFlags(p, CSS_PROPERTY_INTERNAL),
+                     "properties defined in #ifndef "
+                     "CSS_PROP_LIST_EXCLUDE_INTERNAL sections must have "
+                     "the CSS_PROPERTY_INTERNAL flag");
+        }
+      }
+    }
+#endif
+  }
+}
+
+#undef  DEBUG_SHORTHANDS_CONTAINING
+
+bool
+nsCSSProps::BuildShorthandsContainingTable()
+{
+  uint32_t occurrenceCounts[eCSSProperty_COUNT_no_shorthands];
+  memset(occurrenceCounts, 0, sizeof(occurrenceCounts));
+  PropertyAndCount subpropCounts[eCSSProperty_COUNT -
+                                   eCSSProperty_COUNT_no_shorthands];
+  for (nsCSSPropertyID shorthand = eCSSProperty_COUNT_no_shorthands;
+       shorthand < eCSSProperty_COUNT;
+       shorthand = nsCSSPropertyID(shorthand + 1)) {
+#ifdef DEBUG_SHORTHANDS_CONTAINING
+    printf("Considering shorthand property '%s'.\n",
+           nsCSSProps::GetStringValue(shorthand).get());
+#endif
+    PropertyAndCount &subpropCountsEntry =
+      subpropCounts[shorthand - eCSSProperty_COUNT_no_shorthands];
+    subpropCountsEntry.property = shorthand;
+    subpropCountsEntry.count = 0;
+    if (nsCSSProps::PropHasFlags(shorthand, CSS_PROPERTY_IS_ALIAS)) {
+      // Don't put shorthands that are acting as aliases in the
+      // shorthands-containing lists.
+      continue;
+    }
+    for (const nsCSSPropertyID* subprops = SubpropertyEntryFor(shorthand);
+         *subprops != eCSSProperty_UNKNOWN;
+         ++subprops) {
+      MOZ_ASSERT(0 <= *subprops && *subprops < eCSSProperty_COUNT_no_shorthands,
+                 "subproperty must be a longhand");
+      ++occurrenceCounts[*subprops];
+      ++subpropCountsEntry.count;
+    }
+  }
+
+  uint32_t poolEntries = 0;
+  for (nsCSSPropertyID longhand = nsCSSPropertyID(0);
+       longhand < eCSSProperty_COUNT_no_shorthands;
+       longhand = nsCSSPropertyID(longhand + 1)) {
+    uint32_t count = occurrenceCounts[longhand];
+    if (count > 0)
+      // leave room for terminator
+      poolEntries += count + 1;
+  }
+
+  gShorthandsContainingPool = new nsCSSPropertyID[poolEntries];
+  if (!gShorthandsContainingPool)
+    return false;
+
+  // Initialize all entries to point to their null-terminator.
+  {
+    nsCSSPropertyID *poolCursor = gShorthandsContainingPool - 1;
+    nsCSSPropertyID *lastTerminator =
+      gShorthandsContainingPool + poolEntries - 1;
+    for (nsCSSPropertyID longhand = nsCSSPropertyID(0);
+         longhand < eCSSProperty_COUNT_no_shorthands;
+         longhand = nsCSSPropertyID(longhand + 1)) {
+      uint32_t count = occurrenceCounts[longhand];
+      if (count > 0) {
+        poolCursor += count + 1;
+        gShorthandsContainingTable[longhand] = poolCursor;
+        *poolCursor = eCSSProperty_UNKNOWN;
+      } else {
+        gShorthandsContainingTable[longhand] = lastTerminator;
+      }
+    }
+    MOZ_ASSERT(poolCursor == lastTerminator, "miscalculation");
+  }
+
+  // Sort with lowest count at the start and highest at the end, and
+  // within counts sort in reverse property index order.
+  NS_QuickSort(&subpropCounts, ArrayLength(subpropCounts),
+               sizeof(subpropCounts[0]), SortPropertyAndCount, nullptr);
+
+  // Fill in all the entries in gShorthandsContainingTable
+  for (const PropertyAndCount *shorthandAndCount = subpropCounts,
+                           *shorthandAndCountEnd = ArrayEnd(subpropCounts);
+       shorthandAndCount < shorthandAndCountEnd;
+       ++shorthandAndCount) {
+#ifdef DEBUG_SHORTHANDS_CONTAINING
+    printf("Entering %u subprops for '%s'.\n",
+           shorthandAndCount->count,
+           nsCSSProps::GetStringValue(shorthandAndCount->property).get());
+#endif
+    if (nsCSSProps::PropHasFlags(shorthandAndCount->property,
+                                 CSS_PROPERTY_IS_ALIAS)) {
+      // Don't put shorthands that are acting as aliases in the
+      // shorthands-containing lists.
+      continue;
+    }
+    for (const nsCSSPropertyID* subprops =
+           SubpropertyEntryFor(shorthandAndCount->property);
+         *subprops != eCSSProperty_UNKNOWN;
+         ++subprops) {
+      *(--gShorthandsContainingTable[*subprops]) = shorthandAndCount->property;
+    }
+  }
+
+#ifdef DEBUG_SHORTHANDS_CONTAINING
+  for (nsCSSPropertyID longhand = nsCSSPropertyID(0);
+       longhand < eCSSProperty_COUNT_no_shorthands;
+       longhand = nsCSSPropertyID(longhand + 1)) {
+    printf("Property %s is in %d shorthands.\n",
+           nsCSSProps::GetStringValue(longhand).get(),
+           occurrenceCounts[longhand]);
+    for (const nsCSSPropertyID *shorthands = ShorthandsContaining(longhand);
+         *shorthands != eCSSProperty_UNKNOWN;
+         ++shorthands) {
+      printf("  %s\n", nsCSSProps::GetStringValue(*shorthands).get());
+    }
+  }
+#endif
+
+#ifdef DEBUG
+  // Verify that all values that should be are present.
+  for (nsCSSPropertyID shorthand = eCSSProperty_COUNT_no_shorthands;
+       shorthand < eCSSProperty_COUNT;
+       shorthand = nsCSSPropertyID(shorthand + 1)) {
+    if (nsCSSProps::PropHasFlags(shorthand, CSS_PROPERTY_IS_ALIAS)) {
+      // Don't put shorthands that are acting as aliases in the
+      // shorthands-containing lists.
+      continue;
+    }
+    for (const nsCSSPropertyID* subprops = SubpropertyEntryFor(shorthand);
+         *subprops != eCSSProperty_UNKNOWN;
+         ++subprops) {
+      uint32_t count = 0;
+      for (const nsCSSPropertyID *shcont = ShorthandsContaining(*subprops);
+           *shcont != eCSSProperty_UNKNOWN;
+           ++shcont) {
+        if (*shcont == shorthand)
+          ++count;
+      }
+      MOZ_ASSERT(count == 1,
+                 "subproperty of shorthand should have shorthand"
+                 " in its ShorthandsContaining() table");
+    }
+  }
+
+  // Verify that there are no extra values
+  for (nsCSSPropertyID longhand = nsCSSPropertyID(0);
+       longhand < eCSSProperty_COUNT_no_shorthands;
+       longhand = nsCSSPropertyID(longhand + 1)) {
+    for (const nsCSSPropertyID *shorthands = ShorthandsContaining(longhand);
+         *shorthands != eCSSProperty_UNKNOWN;
+         ++shorthands) {
+      uint32_t count = 0;
+      for (const nsCSSPropertyID* subprops = SubpropertyEntryFor(*shorthands);
+           *subprops != eCSSProperty_UNKNOWN;
+           ++subprops) {
+        if (*subprops == longhand)
+          ++count;
+      }
+      MOZ_ASSERT(count == 1,
+                 "longhand should be in subproperty table of "
+                 "property in its ShorthandsContaining() table");
+    }
+  }
+#endif
+
+  return true;
+}
+
+void
+nsCSSProps::ReleaseTable(void)
+{
+  if (0 == --gPropertyTableRefCount) {
+    delete gPropertyTable;
+    gPropertyTable = nullptr;
+
+    delete gFontDescTable;
+    gFontDescTable = nullptr;
+
+    delete gCounterDescTable;
+    gCounterDescTable = nullptr;
+
+    delete gPredefinedCounterStyleTable;
+    gPredefinedCounterStyleTable = nullptr;
+
+    delete gPropertyIDLNameTable;
+    gPropertyIDLNameTable = nullptr;
+
+    delete [] gShorthandsContainingPool;
+    gShorthandsContainingPool = nullptr;
+  }
+}
+
+/* static */ bool
+nsCSSProps::IsInherited(nsCSSPropertyID aProperty)
+{
+  MOZ_ASSERT(!IsShorthand(aProperty));
+
+  nsStyleStructID sid = kSIDTable[aProperty];
+  return nsCachedStyleData::IsInherited(sid);
+}
+
+/* static */ bool
+nsCSSProps::IsCustomPropertyName(const nsACString& aProperty)
+{
+  // Custom properties don't need to have a character after the "--" prefix.
+  return aProperty.Length() >= CSS_CUSTOM_NAME_PREFIX_LENGTH &&
+         StringBeginsWith(aProperty, NS_LITERAL_CSTRING("--"));
+}
+
+/* static */ bool
+nsCSSProps::IsCustomPropertyName(const nsAString& aProperty)
+{
+  return aProperty.Length() >= CSS_CUSTOM_NAME_PREFIX_LENGTH &&
+         StringBeginsWith(aProperty, NS_LITERAL_STRING("--"));
+}
+
+nsCSSPropertyID
+nsCSSProps::LookupProperty(const nsACString& aProperty,
+                           EnabledState aEnabled)
+{
+  MOZ_ASSERT(gPropertyTable, "no lookup table, needs addref");
+
+  if (nsLayoutUtils::CSSVariablesEnabled() &&
+      IsCustomPropertyName(aProperty)) {
+    return eCSSPropertyExtra_variable;
+  }
+
+  nsCSSPropertyID res = nsCSSPropertyID(gPropertyTable->Lookup(aProperty));
+  if (MOZ_LIKELY(res < eCSSProperty_COUNT)) {
+    if (res != eCSSProperty_UNKNOWN && !IsEnabled(res, aEnabled)) {
+      res = eCSSProperty_UNKNOWN;
+    }
+    return res;
+  }
+  MOZ_ASSERT(eCSSAliasCount != 0,
+             "'res' must be an alias at this point so we better have some!");
+  // We intentionally don't support CSSEnabledState::eInUASheets or
+  // CSSEnabledState::eInChrome for aliases yet because it's unlikely
+  // there will be a need for it.
+  if (IsEnabled(res) || aEnabled == CSSEnabledState::eIgnoreEnabledState) {
+    res = gAliases[res - eCSSProperty_COUNT];
+    MOZ_ASSERT(0 <= res && res < eCSSProperty_COUNT,
+               "aliases must not point to other aliases");
+    if (IsEnabled(res) || aEnabled == CSSEnabledState::eIgnoreEnabledState) {
+      return res;
+    }
+  }
+  return eCSSProperty_UNKNOWN;
+}
+
+nsCSSPropertyID
+nsCSSProps::LookupProperty(const nsAString& aProperty, EnabledState aEnabled)
+{
+  if (nsLayoutUtils::CSSVariablesEnabled() &&
+      IsCustomPropertyName(aProperty)) {
+    return eCSSPropertyExtra_variable;
+  }
+
+  // This is faster than converting and calling
+  // LookupProperty(nsACString&).  The table will do its own
+  // converting and avoid a PromiseFlatCString() call.
+  MOZ_ASSERT(gPropertyTable, "no lookup table, needs addref");
+  nsCSSPropertyID res = nsCSSPropertyID(gPropertyTable->Lookup(aProperty));
+  if (MOZ_LIKELY(res < eCSSProperty_COUNT)) {
+    if (res != eCSSProperty_UNKNOWN && !IsEnabled(res, aEnabled)) {
+      res = eCSSProperty_UNKNOWN;
+    }
+    return res;
+  }
+  MOZ_ASSERT(eCSSAliasCount != 0,
+             "'res' must be an alias at this point so we better have some!");
+  // We intentionally don't support CSSEnabledState::eInUASheets or
+  // CSSEnabledState::eInChrome for aliases yet because it's unlikely
+  // there will be a need for it.
+  if (IsEnabled(res) || aEnabled == CSSEnabledState::eIgnoreEnabledState) {
+    res = gAliases[res - eCSSProperty_COUNT];
+    MOZ_ASSERT(0 <= res && res < eCSSProperty_COUNT,
+               "aliases must not point to other aliases");
+    if (IsEnabled(res) || aEnabled == CSSEnabledState::eIgnoreEnabledState) {
+      return res;
+    }
+  }
+  return eCSSProperty_UNKNOWN;
+}
+
+nsCSSPropertyID
+nsCSSProps::LookupPropertyByIDLName(const nsACString& aPropertyIDLName,
+                                    EnabledState aEnabled)
+{
+  nsCSSPropertyID res;
+  if (!gPropertyIDLNameTable->Get(aPropertyIDLName, &res)) {
+    return eCSSProperty_UNKNOWN;
+  }
+  MOZ_ASSERT(res < eCSSProperty_COUNT);
+  if (!IsEnabled(res, aEnabled)) {
+    return eCSSProperty_UNKNOWN;
+  }
+  return res;
+}
+
+nsCSSPropertyID
+nsCSSProps::LookupPropertyByIDLName(const nsAString& aPropertyIDLName,
+                                    EnabledState aEnabled)
+{
+  MOZ_ASSERT(gPropertyIDLNameTable, "no lookup table, needs addref");
+  return LookupPropertyByIDLName(NS_ConvertUTF16toUTF8(aPropertyIDLName),
+                                 aEnabled);
+}
+
+nsCSSFontDesc
+nsCSSProps::LookupFontDesc(const nsACString& aFontDesc)
+{
+  MOZ_ASSERT(gFontDescTable, "no lookup table, needs addref");
+  nsCSSFontDesc which = nsCSSFontDesc(gFontDescTable->Lookup(aFontDesc));
+
+  if (which == eCSSFontDesc_Display &&
+      !Preferences::GetBool("layout.css.font-display.enabled")) {
+    which = eCSSFontDesc_UNKNOWN;
+  } else if (which == eCSSFontDesc_UNKNOWN) {
+    // check for unprefixed font-feature-settings/font-language-override
+    nsAutoCString prefixedProp;
+    prefixedProp.AppendLiteral("-moz-");
+    prefixedProp.Append(aFontDesc);
+    which = nsCSSFontDesc(gFontDescTable->Lookup(prefixedProp));
+  }
+  return which;
+}
+
+nsCSSFontDesc
+nsCSSProps::LookupFontDesc(const nsAString& aFontDesc)
+{
+  MOZ_ASSERT(gFontDescTable, "no lookup table, needs addref");
+  nsCSSFontDesc which = nsCSSFontDesc(gFontDescTable->Lookup(aFontDesc));
+
+  if (which == eCSSFontDesc_Display &&
+      !Preferences::GetBool("layout.css.font-display.enabled")) {
+    which = eCSSFontDesc_UNKNOWN;
+  } else if (which == eCSSFontDesc_UNKNOWN) {
+    // check for unprefixed font-feature-settings/font-language-override
+    nsAutoString prefixedProp;
+    prefixedProp.AppendLiteral("-moz-");
+    prefixedProp.Append(aFontDesc);
+    which = nsCSSFontDesc(gFontDescTable->Lookup(prefixedProp));
+  }
+  return which;
+}
+
+nsCSSCounterDesc
+nsCSSProps::LookupCounterDesc(const nsAString& aProperty)
+{
+  MOZ_ASSERT(gCounterDescTable, "no lookup table, needs addref");
+  return nsCSSCounterDesc(gCounterDescTable->Lookup(aProperty));
+}
+
+nsCSSCounterDesc
+nsCSSProps::LookupCounterDesc(const nsACString& aProperty)
+{
+  MOZ_ASSERT(gCounterDescTable, "no lookup table, needs addref");
+  return nsCSSCounterDesc(gCounterDescTable->Lookup(aProperty));
+}
+
+bool
+nsCSSProps::IsPredefinedCounterStyle(const nsAString& aStyle)
+{
+  MOZ_ASSERT(gPredefinedCounterStyleTable,
+             "no lookup table, needs addref");
+  return gPredefinedCounterStyleTable->Lookup(aStyle) !=
+    nsStaticCaseInsensitiveNameTable::NOT_FOUND;
+}
+
+bool
+nsCSSProps::IsPredefinedCounterStyle(const nsACString& aStyle)
+{
+  MOZ_ASSERT(gPredefinedCounterStyleTable,
+             "no lookup table, needs addref");
+  return gPredefinedCounterStyleTable->Lookup(aStyle) !=
+    nsStaticCaseInsensitiveNameTable::NOT_FOUND;
+}
+
+const nsAFlatCString&
+nsCSSProps::GetStringValue(nsCSSPropertyID aProperty)
+{
+  MOZ_ASSERT(gPropertyTable, "no lookup table, needs addref");
+  if (gPropertyTable) {
+    return gPropertyTable->GetStringValue(int32_t(aProperty));
+  } else {
+    static nsDependentCString sNullStr("");
+    return sNullStr;
+  }
+}
+
+const nsAFlatCString&
+nsCSSProps::GetStringValue(nsCSSFontDesc aFontDescID)
+{
+  MOZ_ASSERT(gFontDescTable, "no lookup table, needs addref");
+  if (gFontDescTable) {
+    return gFontDescTable->GetStringValue(int32_t(aFontDescID));
+  } else {
+    static nsDependentCString sNullStr("");
+    return sNullStr;
+  }
+}
+
+const nsAFlatCString&
+nsCSSProps::GetStringValue(nsCSSCounterDesc aCounterDesc)
+{
+  MOZ_ASSERT(gCounterDescTable, "no lookup table, needs addref");
+  if (gCounterDescTable) {
+    return gCounterDescTable->GetStringValue(int32_t(aCounterDesc));
+  } else {
+    static nsDependentCString sNullStr("");
+    return sNullStr;
+  }
+}
+
+#define CSS_PROP(name_, id_, ...) nsICSSProperty* nsCSSProps::id_;
+#define CSS_PROP_SHORTHAND(name_, id_, ...) CSS_PROP(name_, id_, ...)
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP_SHORTHAND
+#undef CSS_PROP
+
+#define CSS_PROP(name_, id_, ...) NS_STATIC_ATOM_BUFFER(id_##_buffer, #name_)
+#define CSS_PROP_SHORTHAND(name_, id_, ...) CSS_PROP(name_, id_, ...)
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP_SHORTHAND
+#undef CSS_PROP
+
+static const nsStaticAtom CSSProps_info[] = {
+#define CSS_PROP(name_, id_, ...) \
+  NS_STATIC_ATOM(id_##_buffer, (nsIAtom**)&nsCSSProps::id_),
+#define CSS_PROP_SHORTHAND(name_, id_, ...) CSS_PROP(name_, id_, __VA_ARGS__)
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP_SHORTHAND
+#undef CSS_PROP
+};
+
+nsICSSProperty* nsCSSProps::gPropertyAtomTable[eCSSProperty_COUNT];
+
+/* static */ void
+nsCSSProps::AddRefAtoms()
+{
+  NS_RegisterStaticAtoms(CSSProps_info);
+#define CSS_PROP(name_, id_, ...) \
+  gPropertyAtomTable[eCSSProperty_##id_] = nsCSSProps::id_;
+#define CSS_PROP_SHORTHAND(name_, id_, ...) CSS_PROP(name_, id_, ...)
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP_SHORTHAND
+#undef CSS_PROP
+}
+
+/***************************************************************************/
+
+const KTableEntry nsCSSProps::kAnimationDirectionKTable[] = {
+  { eCSSKeyword_normal, static_cast<uint32_t>(dom::PlaybackDirection::Normal) },
+  { eCSSKeyword_reverse, static_cast<uint32_t>(dom::PlaybackDirection::Reverse) },
+  { eCSSKeyword_alternate, static_cast<uint32_t>(dom::PlaybackDirection::Alternate) },
+  { eCSSKeyword_alternate_reverse, static_cast<uint32_t>(dom::PlaybackDirection::Alternate_reverse) },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kAnimationFillModeKTable[] = {
+  { eCSSKeyword_none, static_cast<uint32_t>(dom::FillMode::None) },
+  { eCSSKeyword_forwards, static_cast<uint32_t>(dom::FillMode::Forwards) },
+  { eCSSKeyword_backwards, static_cast<uint32_t>(dom::FillMode::Backwards) },
+  { eCSSKeyword_both, static_cast<uint32_t>(dom::FillMode::Both) },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kAnimationIterationCountKTable[] = {
+  { eCSSKeyword_infinite, NS_STYLE_ANIMATION_ITERATION_COUNT_INFINITE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kAnimationPlayStateKTable[] = {
+  { eCSSKeyword_running, NS_STYLE_ANIMATION_PLAY_STATE_RUNNING },
+  { eCSSKeyword_paused, NS_STYLE_ANIMATION_PLAY_STATE_PAUSED },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kAppearanceKTable[] = {
+  { eCSSKeyword_none,                   NS_THEME_NONE },
+  { eCSSKeyword_button,                 NS_THEME_BUTTON },
+  { eCSSKeyword_radio,                  NS_THEME_RADIO },
+  { eCSSKeyword_checkbox,               NS_THEME_CHECKBOX },
+  { eCSSKeyword_button_bevel,           NS_THEME_BUTTON_BEVEL },
+  { eCSSKeyword_toolbox,                NS_THEME_TOOLBOX },
+  { eCSSKeyword_toolbar,                NS_THEME_TOOLBAR },
+  { eCSSKeyword_toolbarbutton,          NS_THEME_TOOLBARBUTTON },
+  { eCSSKeyword_toolbargripper,         NS_THEME_TOOLBARGRIPPER },
+  { eCSSKeyword_dualbutton,             NS_THEME_DUALBUTTON },
+  { eCSSKeyword_toolbarbutton_dropdown, NS_THEME_TOOLBARBUTTON_DROPDOWN },
+  { eCSSKeyword_button_arrow_up,        NS_THEME_BUTTON_ARROW_UP },
+  { eCSSKeyword_button_arrow_down,      NS_THEME_BUTTON_ARROW_DOWN },
+  { eCSSKeyword_button_arrow_next,      NS_THEME_BUTTON_ARROW_NEXT },
+  { eCSSKeyword_button_arrow_previous,  NS_THEME_BUTTON_ARROW_PREVIOUS },
+  { eCSSKeyword_meterbar,               NS_THEME_METERBAR },
+  { eCSSKeyword_meterchunk,             NS_THEME_METERCHUNK },
+  { eCSSKeyword_number_input,           NS_THEME_NUMBER_INPUT },
+  { eCSSKeyword_separator,              NS_THEME_SEPARATOR },
+  { eCSSKeyword_splitter,               NS_THEME_SPLITTER },
+  { eCSSKeyword_statusbar,              NS_THEME_STATUSBAR },
+  { eCSSKeyword_statusbarpanel,         NS_THEME_STATUSBARPANEL },
+  { eCSSKeyword_resizerpanel,           NS_THEME_RESIZERPANEL },
+  { eCSSKeyword_resizer,                NS_THEME_RESIZER },
+  { eCSSKeyword_listbox,                NS_THEME_LISTBOX },
+  { eCSSKeyword_listitem,               NS_THEME_LISTITEM },
+  { eCSSKeyword_treeview,               NS_THEME_TREEVIEW },
+  { eCSSKeyword_treeitem,               NS_THEME_TREEITEM },
+  { eCSSKeyword_treetwisty,             NS_THEME_TREETWISTY },
+  { eCSSKeyword_treetwistyopen,         NS_THEME_TREETWISTYOPEN },
+  { eCSSKeyword_treeline,               NS_THEME_TREELINE },
+  { eCSSKeyword_treeheader,             NS_THEME_TREEHEADER },
+  { eCSSKeyword_treeheadercell,         NS_THEME_TREEHEADERCELL },
+  { eCSSKeyword_treeheadersortarrow,    NS_THEME_TREEHEADERSORTARROW },
+  { eCSSKeyword_progressbar,            NS_THEME_PROGRESSBAR },
+  { eCSSKeyword_progresschunk,          NS_THEME_PROGRESSCHUNK },
+  { eCSSKeyword_progressbar_vertical,   NS_THEME_PROGRESSBAR_VERTICAL },
+  { eCSSKeyword_progresschunk_vertical, NS_THEME_PROGRESSCHUNK_VERTICAL },
+  { eCSSKeyword_tab,                    NS_THEME_TAB },
+  { eCSSKeyword_tabpanels,              NS_THEME_TABPANELS },
+  { eCSSKeyword_tabpanel,               NS_THEME_TABPANEL },
+  { eCSSKeyword_tab_scroll_arrow_back,  NS_THEME_TAB_SCROLL_ARROW_BACK },
+  { eCSSKeyword_tab_scroll_arrow_forward, NS_THEME_TAB_SCROLL_ARROW_FORWARD },
+  { eCSSKeyword_tooltip,                NS_THEME_TOOLTIP },
+  { eCSSKeyword_spinner,                NS_THEME_SPINNER },
+  { eCSSKeyword_spinner_upbutton,       NS_THEME_SPINNER_UPBUTTON },
+  { eCSSKeyword_spinner_downbutton,     NS_THEME_SPINNER_DOWNBUTTON },
+  { eCSSKeyword_spinner_textfield,      NS_THEME_SPINNER_TEXTFIELD },
+  { eCSSKeyword_scrollbar,              NS_THEME_SCROLLBAR },
+  { eCSSKeyword_scrollbar_small,        NS_THEME_SCROLLBAR_SMALL },
+  { eCSSKeyword_scrollbar_horizontal,   NS_THEME_SCROLLBAR_HORIZONTAL },
+  { eCSSKeyword_scrollbar_vertical,     NS_THEME_SCROLLBAR_VERTICAL },
+  { eCSSKeyword_scrollbarbutton_up,     NS_THEME_SCROLLBARBUTTON_UP },
+  { eCSSKeyword_scrollbarbutton_down,   NS_THEME_SCROLLBARBUTTON_DOWN },
+  { eCSSKeyword_scrollbarbutton_left,   NS_THEME_SCROLLBARBUTTON_LEFT },
+  { eCSSKeyword_scrollbarbutton_right,  NS_THEME_SCROLLBARBUTTON_RIGHT },
+  { eCSSKeyword_scrollbartrack_horizontal,    NS_THEME_SCROLLBARTRACK_HORIZONTAL },
+  { eCSSKeyword_scrollbartrack_vertical,      NS_THEME_SCROLLBARTRACK_VERTICAL },
+  { eCSSKeyword_scrollbarthumb_horizontal,    NS_THEME_SCROLLBARTHUMB_HORIZONTAL },
+  { eCSSKeyword_scrollbarthumb_vertical,      NS_THEME_SCROLLBARTHUMB_VERTICAL },
+  { eCSSKeyword_textfield,              NS_THEME_TEXTFIELD },
+  { eCSSKeyword_textfield_multiline,    NS_THEME_TEXTFIELD_MULTILINE },
+  { eCSSKeyword_caret,                  NS_THEME_CARET },
+  { eCSSKeyword_searchfield,            NS_THEME_SEARCHFIELD },
+  { eCSSKeyword_menulist,               NS_THEME_MENULIST },
+  { eCSSKeyword_menulist_button,        NS_THEME_MENULIST_BUTTON },
+  { eCSSKeyword_menulist_text,          NS_THEME_MENULIST_TEXT },
+  { eCSSKeyword_menulist_textfield,     NS_THEME_MENULIST_TEXTFIELD },
+  { eCSSKeyword_range,                  NS_THEME_RANGE },
+  { eCSSKeyword_range_thumb,            NS_THEME_RANGE_THUMB },
+  { eCSSKeyword_scale_horizontal,       NS_THEME_SCALE_HORIZONTAL },
+  { eCSSKeyword_scale_vertical,         NS_THEME_SCALE_VERTICAL },
+  { eCSSKeyword_scalethumb_horizontal,  NS_THEME_SCALETHUMB_HORIZONTAL },
+  { eCSSKeyword_scalethumb_vertical,    NS_THEME_SCALETHUMB_VERTICAL },
+  { eCSSKeyword_scalethumbstart,        NS_THEME_SCALETHUMBSTART },
+  { eCSSKeyword_scalethumbend,          NS_THEME_SCALETHUMBEND },
+  { eCSSKeyword_scalethumbtick,         NS_THEME_SCALETHUMBTICK },
+  { eCSSKeyword_groupbox,               NS_THEME_GROUPBOX },
+  { eCSSKeyword_checkbox_container,     NS_THEME_CHECKBOX_CONTAINER },
+  { eCSSKeyword_radio_container,        NS_THEME_RADIO_CONTAINER },
+  { eCSSKeyword_checkbox_label,         NS_THEME_CHECKBOX_LABEL },
+  { eCSSKeyword_radio_label,            NS_THEME_RADIO_LABEL },
+  { eCSSKeyword_button_focus,           NS_THEME_BUTTON_FOCUS },
+  { eCSSKeyword_window,                 NS_THEME_WINDOW },
+  { eCSSKeyword_dialog,                 NS_THEME_DIALOG },
+  { eCSSKeyword_menubar,                NS_THEME_MENUBAR },
+  { eCSSKeyword_menupopup,              NS_THEME_MENUPOPUP },
+  { eCSSKeyword_menuitem,               NS_THEME_MENUITEM },
+  { eCSSKeyword_checkmenuitem,          NS_THEME_CHECKMENUITEM },
+  { eCSSKeyword_radiomenuitem,          NS_THEME_RADIOMENUITEM },
+  { eCSSKeyword_menucheckbox,           NS_THEME_MENUCHECKBOX },
+  { eCSSKeyword_menuradio,              NS_THEME_MENURADIO },
+  { eCSSKeyword_menuseparator,          NS_THEME_MENUSEPARATOR },
+  { eCSSKeyword_menuarrow,              NS_THEME_MENUARROW },
+  { eCSSKeyword_menuimage,              NS_THEME_MENUIMAGE },
+  { eCSSKeyword_menuitemtext,           NS_THEME_MENUITEMTEXT },
+  { eCSSKeyword__moz_win_media_toolbox, NS_THEME_WIN_MEDIA_TOOLBOX },
+  { eCSSKeyword__moz_win_communications_toolbox, NS_THEME_WIN_COMMUNICATIONS_TOOLBOX },
+  { eCSSKeyword__moz_win_browsertabbar_toolbox,  NS_THEME_WIN_BROWSERTABBAR_TOOLBOX },
+  { eCSSKeyword__moz_win_glass,         NS_THEME_WIN_GLASS },
+  { eCSSKeyword__moz_win_borderless_glass,      NS_THEME_WIN_BORDERLESS_GLASS },
+  { eCSSKeyword__moz_mac_fullscreen_button,     NS_THEME_MAC_FULLSCREEN_BUTTON },
+  { eCSSKeyword__moz_mac_help_button,           NS_THEME_MAC_HELP_BUTTON },
+  { eCSSKeyword__moz_window_titlebar,           NS_THEME_WINDOW_TITLEBAR },
+  { eCSSKeyword__moz_window_titlebar_maximized, NS_THEME_WINDOW_TITLEBAR_MAXIMIZED },
+  { eCSSKeyword__moz_window_frame_left,         NS_THEME_WINDOW_FRAME_LEFT },
+  { eCSSKeyword__moz_window_frame_right,        NS_THEME_WINDOW_FRAME_RIGHT },
+  { eCSSKeyword__moz_window_frame_bottom,       NS_THEME_WINDOW_FRAME_BOTTOM },
+  { eCSSKeyword__moz_window_button_close,       NS_THEME_WINDOW_BUTTON_CLOSE },
+  { eCSSKeyword__moz_window_button_minimize,    NS_THEME_WINDOW_BUTTON_MINIMIZE },
+  { eCSSKeyword__moz_window_button_maximize,    NS_THEME_WINDOW_BUTTON_MAXIMIZE },
+  { eCSSKeyword__moz_window_button_restore,     NS_THEME_WINDOW_BUTTON_RESTORE },
+  { eCSSKeyword__moz_window_button_box,         NS_THEME_WINDOW_BUTTON_BOX },
+  { eCSSKeyword__moz_window_button_box_maximized, NS_THEME_WINDOW_BUTTON_BOX_MAXIMIZED },
+  { eCSSKeyword__moz_win_exclude_glass,         NS_THEME_WIN_EXCLUDE_GLASS },
+  { eCSSKeyword__moz_mac_vibrancy_light,        NS_THEME_MAC_VIBRANCY_LIGHT },
+  { eCSSKeyword__moz_mac_vibrancy_dark,         NS_THEME_MAC_VIBRANCY_DARK },
+  { eCSSKeyword__moz_mac_disclosure_button_open,   NS_THEME_MAC_DISCLOSURE_BUTTON_OPEN },
+  { eCSSKeyword__moz_mac_disclosure_button_closed, NS_THEME_MAC_DISCLOSURE_BUTTON_CLOSED },
+  { eCSSKeyword__moz_gtk_info_bar,              NS_THEME_GTK_INFO_BAR },
+  { eCSSKeyword__moz_mac_source_list,           NS_THEME_MAC_SOURCE_LIST },
+  { eCSSKeyword__moz_mac_source_list_selection, NS_THEME_MAC_SOURCE_LIST_SELECTION },
+  { eCSSKeyword__moz_mac_active_source_list_selection, NS_THEME_MAC_ACTIVE_SOURCE_LIST_SELECTION },
+  { eCSSKeyword_UNKNOWN,                        -1 }
+};
+
+const KTableEntry nsCSSProps::kBackfaceVisibilityKTable[] = {
+  { eCSSKeyword_visible, NS_STYLE_BACKFACE_VISIBILITY_VISIBLE },
+  { eCSSKeyword_hidden, NS_STYLE_BACKFACE_VISIBILITY_HIDDEN },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTransformStyleKTable[] = {
+  { eCSSKeyword_flat, NS_STYLE_TRANSFORM_STYLE_FLAT },
+  { eCSSKeyword_preserve_3d, NS_STYLE_TRANSFORM_STYLE_PRESERVE_3D },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kImageLayerAttachmentKTable[] = {
+  { eCSSKeyword_fixed, NS_STYLE_IMAGELAYER_ATTACHMENT_FIXED },
+  { eCSSKeyword_scroll, NS_STYLE_IMAGELAYER_ATTACHMENT_SCROLL },
+  { eCSSKeyword_local, NS_STYLE_IMAGELAYER_ATTACHMENT_LOCAL },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+static_assert(NS_STYLE_IMAGELAYER_CLIP_BORDER == NS_STYLE_IMAGELAYER_ORIGIN_BORDER &&
+              NS_STYLE_IMAGELAYER_CLIP_PADDING == NS_STYLE_IMAGELAYER_ORIGIN_PADDING &&
+              NS_STYLE_IMAGELAYER_CLIP_CONTENT == NS_STYLE_IMAGELAYER_ORIGIN_CONTENT,
+              "Except background-clip:text, all {background,mask}-clip and "
+              "{background,mask}-origin style constants must agree");
+
+const KTableEntry nsCSSProps::kImageLayerOriginKTable[] = {
+  { eCSSKeyword_border_box, NS_STYLE_IMAGELAYER_ORIGIN_BORDER },
+  { eCSSKeyword_padding_box, NS_STYLE_IMAGELAYER_ORIGIN_PADDING },
+  { eCSSKeyword_content_box, NS_STYLE_IMAGELAYER_ORIGIN_CONTENT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+KTableEntry nsCSSProps::kBackgroundClipKTable[] = {
+  { eCSSKeyword_border_box, NS_STYLE_IMAGELAYER_CLIP_BORDER },
+  { eCSSKeyword_padding_box, NS_STYLE_IMAGELAYER_CLIP_PADDING },
+  { eCSSKeyword_content_box, NS_STYLE_IMAGELAYER_CLIP_CONTENT },
+  // The next entry is controlled by the layout.css.background-clip-text.enabled
+  // pref.
+  { eCSSKeyword_text, NS_STYLE_IMAGELAYER_CLIP_TEXT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+static_assert(MOZ_ARRAY_LENGTH(nsCSSProps::kImageLayerOriginKTable) ==
+              MOZ_ARRAY_LENGTH(nsCSSProps::kBackgroundClipKTable) - 1,
+              "background-clip has one extra value, which is text, compared"
+              "to {background,mask}-origin");
+
+// Note: Don't change this table unless you update
+// ParseImageLayerPosition!
+
+const KTableEntry nsCSSProps::kImageLayerPositionKTable[] = {
+  { eCSSKeyword_center, NS_STYLE_IMAGELAYER_POSITION_CENTER },
+  { eCSSKeyword_top, NS_STYLE_IMAGELAYER_POSITION_TOP },
+  { eCSSKeyword_bottom, NS_STYLE_IMAGELAYER_POSITION_BOTTOM },
+  { eCSSKeyword_left, NS_STYLE_IMAGELAYER_POSITION_LEFT },
+  { eCSSKeyword_right, NS_STYLE_IMAGELAYER_POSITION_RIGHT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kImageLayerRepeatKTable[] = {
+  { eCSSKeyword_no_repeat,  NS_STYLE_IMAGELAYER_REPEAT_NO_REPEAT },
+  { eCSSKeyword_repeat,     NS_STYLE_IMAGELAYER_REPEAT_REPEAT },
+  { eCSSKeyword_repeat_x,   NS_STYLE_IMAGELAYER_REPEAT_REPEAT_X },
+  { eCSSKeyword_repeat_y,   NS_STYLE_IMAGELAYER_REPEAT_REPEAT_Y },
+  { eCSSKeyword_round,      NS_STYLE_IMAGELAYER_REPEAT_ROUND},
+  { eCSSKeyword_space,      NS_STYLE_IMAGELAYER_REPEAT_SPACE},
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kImageLayerRepeatPartKTable[] = {
+  { eCSSKeyword_no_repeat,  NS_STYLE_IMAGELAYER_REPEAT_NO_REPEAT },
+  { eCSSKeyword_repeat,     NS_STYLE_IMAGELAYER_REPEAT_REPEAT },
+  { eCSSKeyword_round,      NS_STYLE_IMAGELAYER_REPEAT_ROUND},
+  { eCSSKeyword_space,      NS_STYLE_IMAGELAYER_REPEAT_SPACE},
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kImageLayerSizeKTable[] = {
+  { eCSSKeyword_contain, NS_STYLE_IMAGELAYER_SIZE_CONTAIN },
+  { eCSSKeyword_cover,   NS_STYLE_IMAGELAYER_SIZE_COVER },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kImageLayerModeKTable[] = {
+  { eCSSKeyword_alpha, NS_STYLE_MASK_MODE_ALPHA },
+  { eCSSKeyword_luminance, NS_STYLE_MASK_MODE_LUMINANCE },
+  { eCSSKeyword_match_source, NS_STYLE_MASK_MODE_MATCH_SOURCE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kImageLayerCompositeKTable[] = {
+  { eCSSKeyword_add, NS_STYLE_MASK_COMPOSITE_ADD },
+  { eCSSKeyword_subtract, NS_STYLE_MASK_COMPOSITE_SUBTRACT },
+  { eCSSKeyword_intersect, NS_STYLE_MASK_COMPOSITE_INTERSECT },
+  { eCSSKeyword_exclude, NS_STYLE_MASK_COMPOSITE_EXCLUDE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kBlendModeKTable[] = {
+    { eCSSKeyword_normal,      NS_STYLE_BLEND_NORMAL },
+    { eCSSKeyword_multiply,    NS_STYLE_BLEND_MULTIPLY },
+    { eCSSKeyword_screen,      NS_STYLE_BLEND_SCREEN },
+    { eCSSKeyword_overlay,     NS_STYLE_BLEND_OVERLAY },
+    { eCSSKeyword_darken,      NS_STYLE_BLEND_DARKEN },
+    { eCSSKeyword_lighten,     NS_STYLE_BLEND_LIGHTEN },
+    { eCSSKeyword_color_dodge, NS_STYLE_BLEND_COLOR_DODGE },
+    { eCSSKeyword_color_burn,  NS_STYLE_BLEND_COLOR_BURN },
+    { eCSSKeyword_hard_light,  NS_STYLE_BLEND_HARD_LIGHT },
+    { eCSSKeyword_soft_light,  NS_STYLE_BLEND_SOFT_LIGHT },
+    { eCSSKeyword_difference,  NS_STYLE_BLEND_DIFFERENCE },
+    { eCSSKeyword_exclusion,   NS_STYLE_BLEND_EXCLUSION },
+    { eCSSKeyword_hue,         NS_STYLE_BLEND_HUE },
+    { eCSSKeyword_saturation,  NS_STYLE_BLEND_SATURATION },
+    { eCSSKeyword_color,       NS_STYLE_BLEND_COLOR },
+    { eCSSKeyword_luminosity,  NS_STYLE_BLEND_LUMINOSITY },
+    { eCSSKeyword_UNKNOWN,     -1 }
+};
+
+const KTableEntry nsCSSProps::kBorderCollapseKTable[] = {
+  { eCSSKeyword_collapse,  NS_STYLE_BORDER_COLLAPSE },
+  { eCSSKeyword_separate,  NS_STYLE_BORDER_SEPARATE },
+  { eCSSKeyword_UNKNOWN,   -1 }
+};
+
+const KTableEntry nsCSSProps::kBorderImageRepeatKTable[] = {
+  { eCSSKeyword_stretch, NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH },
+  { eCSSKeyword_repeat, NS_STYLE_BORDER_IMAGE_REPEAT_REPEAT },
+  { eCSSKeyword_round, NS_STYLE_BORDER_IMAGE_REPEAT_ROUND },
+  { eCSSKeyword_space, NS_STYLE_BORDER_IMAGE_REPEAT_SPACE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kBorderImageSliceKTable[] = {
+  { eCSSKeyword_fill, NS_STYLE_BORDER_IMAGE_SLICE_FILL },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kBorderStyleKTable[] = {
+  { eCSSKeyword_none,   NS_STYLE_BORDER_STYLE_NONE },
+  { eCSSKeyword_hidden, NS_STYLE_BORDER_STYLE_HIDDEN },
+  { eCSSKeyword_dotted, NS_STYLE_BORDER_STYLE_DOTTED },
+  { eCSSKeyword_dashed, NS_STYLE_BORDER_STYLE_DASHED },
+  { eCSSKeyword_solid,  NS_STYLE_BORDER_STYLE_SOLID },
+  { eCSSKeyword_double, NS_STYLE_BORDER_STYLE_DOUBLE },
+  { eCSSKeyword_groove, NS_STYLE_BORDER_STYLE_GROOVE },
+  { eCSSKeyword_ridge,  NS_STYLE_BORDER_STYLE_RIDGE },
+  { eCSSKeyword_inset,  NS_STYLE_BORDER_STYLE_INSET },
+  { eCSSKeyword_outset, NS_STYLE_BORDER_STYLE_OUTSET },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kBorderWidthKTable[] = {
+  { eCSSKeyword_thin, NS_STYLE_BORDER_WIDTH_THIN },
+  { eCSSKeyword_medium, NS_STYLE_BORDER_WIDTH_MEDIUM },
+  { eCSSKeyword_thick, NS_STYLE_BORDER_WIDTH_THICK },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kBoxDecorationBreakKTable[] = {
+  { eCSSKeyword_slice, StyleBoxDecorationBreak::Slice },
+  { eCSSKeyword_clone, StyleBoxDecorationBreak::Clone },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kBoxShadowTypeKTable[] = {
+  { eCSSKeyword_inset, uint8_t(StyleBoxShadowType::Inset) },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kBoxSizingKTable[] = {
+  { eCSSKeyword_content_box,  StyleBoxSizing::Content },
+  { eCSSKeyword_border_box,   StyleBoxSizing::Border },
+  { eCSSKeyword_UNKNOWN,      -1 }
+};
+
+const KTableEntry nsCSSProps::kCaptionSideKTable[] = {
+  { eCSSKeyword_top,                  NS_STYLE_CAPTION_SIDE_TOP },
+  { eCSSKeyword_right,                NS_STYLE_CAPTION_SIDE_RIGHT },
+  { eCSSKeyword_bottom,               NS_STYLE_CAPTION_SIDE_BOTTOM },
+  { eCSSKeyword_left,                 NS_STYLE_CAPTION_SIDE_LEFT },
+  { eCSSKeyword_top_outside,          NS_STYLE_CAPTION_SIDE_TOP_OUTSIDE },
+  { eCSSKeyword_bottom_outside,       NS_STYLE_CAPTION_SIDE_BOTTOM_OUTSIDE },
+  { eCSSKeyword_UNKNOWN,              -1 }
+};
+
+KTableEntry nsCSSProps::kClearKTable[] = {
+  { eCSSKeyword_none, StyleClear::None },
+  { eCSSKeyword_left, StyleClear::Left },
+  { eCSSKeyword_right, StyleClear::Right },
+  { eCSSKeyword_inline_start, StyleClear::InlineStart },
+  { eCSSKeyword_inline_end, StyleClear::InlineEnd },
+  { eCSSKeyword_both, StyleClear::Both },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+// See also kContextPatternKTable for SVG paint-specific values
+const KTableEntry nsCSSProps::kColorKTable[] = {
+  { eCSSKeyword_activeborder, LookAndFeel::eColorID_activeborder },
+  { eCSSKeyword_activecaption, LookAndFeel::eColorID_activecaption },
+  { eCSSKeyword_appworkspace, LookAndFeel::eColorID_appworkspace },
+  { eCSSKeyword_background, LookAndFeel::eColorID_background },
+  { eCSSKeyword_buttonface, LookAndFeel::eColorID_buttonface },
+  { eCSSKeyword_buttonhighlight, LookAndFeel::eColorID_buttonhighlight },
+  { eCSSKeyword_buttonshadow, LookAndFeel::eColorID_buttonshadow },
+  { eCSSKeyword_buttontext, LookAndFeel::eColorID_buttontext },
+  { eCSSKeyword_captiontext, LookAndFeel::eColorID_captiontext },
+  { eCSSKeyword_graytext, LookAndFeel::eColorID_graytext },
+  { eCSSKeyword_highlight, LookAndFeel::eColorID_highlight },
+  { eCSSKeyword_highlighttext, LookAndFeel::eColorID_highlighttext },
+  { eCSSKeyword_inactiveborder, LookAndFeel::eColorID_inactiveborder },
+  { eCSSKeyword_inactivecaption, LookAndFeel::eColorID_inactivecaption },
+  { eCSSKeyword_inactivecaptiontext, LookAndFeel::eColorID_inactivecaptiontext },
+  { eCSSKeyword_infobackground, LookAndFeel::eColorID_infobackground },
+  { eCSSKeyword_infotext, LookAndFeel::eColorID_infotext },
+  { eCSSKeyword_menu, LookAndFeel::eColorID_menu },
+  { eCSSKeyword_menutext, LookAndFeel::eColorID_menutext },
+  { eCSSKeyword_scrollbar, LookAndFeel::eColorID_scrollbar },
+  { eCSSKeyword_threeddarkshadow, LookAndFeel::eColorID_threeddarkshadow },
+  { eCSSKeyword_threedface, LookAndFeel::eColorID_threedface },
+  { eCSSKeyword_threedhighlight, LookAndFeel::eColorID_threedhighlight },
+  { eCSSKeyword_threedlightshadow, LookAndFeel::eColorID_threedlightshadow },
+  { eCSSKeyword_threedshadow, LookAndFeel::eColorID_threedshadow },
+  { eCSSKeyword_window, LookAndFeel::eColorID_window },
+  { eCSSKeyword_windowframe, LookAndFeel::eColorID_windowframe },
+  { eCSSKeyword_windowtext, LookAndFeel::eColorID_windowtext },
+  { eCSSKeyword__moz_activehyperlinktext, NS_COLOR_MOZ_ACTIVEHYPERLINKTEXT },
+  { eCSSKeyword__moz_buttondefault, LookAndFeel::eColorID__moz_buttondefault },
+  { eCSSKeyword__moz_buttonhoverface, LookAndFeel::eColorID__moz_buttonhoverface },
+  { eCSSKeyword__moz_buttonhovertext, LookAndFeel::eColorID__moz_buttonhovertext },
+  { eCSSKeyword__moz_cellhighlight, LookAndFeel::eColorID__moz_cellhighlight },
+  { eCSSKeyword__moz_cellhighlighttext, LookAndFeel::eColorID__moz_cellhighlighttext },
+  { eCSSKeyword__moz_eventreerow, LookAndFeel::eColorID__moz_eventreerow },
+  { eCSSKeyword__moz_field, LookAndFeel::eColorID__moz_field },
+  { eCSSKeyword__moz_fieldtext, LookAndFeel::eColorID__moz_fieldtext },
+  { eCSSKeyword__moz_default_background_color, NS_COLOR_MOZ_DEFAULT_BACKGROUND_COLOR },
+  { eCSSKeyword__moz_default_color, NS_COLOR_MOZ_DEFAULT_COLOR },
+  { eCSSKeyword__moz_dialog, LookAndFeel::eColorID__moz_dialog },
+  { eCSSKeyword__moz_dialogtext, LookAndFeel::eColorID__moz_dialogtext },
+  { eCSSKeyword__moz_dragtargetzone, LookAndFeel::eColorID__moz_dragtargetzone },
+  { eCSSKeyword__moz_gtk_info_bar_text, LookAndFeel::eColorID__moz_gtk_info_bar_text },
+  { eCSSKeyword__moz_hyperlinktext, NS_COLOR_MOZ_HYPERLINKTEXT },
+  { eCSSKeyword__moz_html_cellhighlight, LookAndFeel::eColorID__moz_html_cellhighlight },
+  { eCSSKeyword__moz_html_cellhighlighttext, LookAndFeel::eColorID__moz_html_cellhighlighttext },
+  { eCSSKeyword__moz_mac_buttonactivetext, LookAndFeel::eColorID__moz_mac_buttonactivetext },
+  { eCSSKeyword__moz_mac_chrome_active, LookAndFeel::eColorID__moz_mac_chrome_active },
+  { eCSSKeyword__moz_mac_chrome_inactive, LookAndFeel::eColorID__moz_mac_chrome_inactive },
+  { eCSSKeyword__moz_mac_defaultbuttontext, LookAndFeel::eColorID__moz_mac_defaultbuttontext },
+  { eCSSKeyword__moz_mac_focusring, LookAndFeel::eColorID__moz_mac_focusring },
+  { eCSSKeyword__moz_mac_menuselect, LookAndFeel::eColorID__moz_mac_menuselect },
+  { eCSSKeyword__moz_mac_menushadow, LookAndFeel::eColorID__moz_mac_menushadow },
+  { eCSSKeyword__moz_mac_menutextdisable, LookAndFeel::eColorID__moz_mac_menutextdisable },
+  { eCSSKeyword__moz_mac_menutextselect, LookAndFeel::eColorID__moz_mac_menutextselect },
+  { eCSSKeyword__moz_mac_disabledtoolbartext, LookAndFeel::eColorID__moz_mac_disabledtoolbartext },
+  { eCSSKeyword__moz_mac_secondaryhighlight, LookAndFeel::eColorID__moz_mac_secondaryhighlight },
+  { eCSSKeyword__moz_menuhover, LookAndFeel::eColorID__moz_menuhover },
+  { eCSSKeyword__moz_menuhovertext, LookAndFeel::eColorID__moz_menuhovertext },
+  { eCSSKeyword__moz_menubartext, LookAndFeel::eColorID__moz_menubartext },
+  { eCSSKeyword__moz_menubarhovertext, LookAndFeel::eColorID__moz_menubarhovertext },
+  { eCSSKeyword__moz_oddtreerow, LookAndFeel::eColorID__moz_oddtreerow },
+  { eCSSKeyword__moz_visitedhyperlinktext, NS_COLOR_MOZ_VISITEDHYPERLINKTEXT },
+  { eCSSKeyword_currentcolor, NS_COLOR_CURRENTCOLOR },
+  { eCSSKeyword__moz_win_mediatext, LookAndFeel::eColorID__moz_win_mediatext },
+  { eCSSKeyword__moz_win_communicationstext, LookAndFeel::eColorID__moz_win_communicationstext },
+  { eCSSKeyword__moz_nativehyperlinktext, LookAndFeel::eColorID__moz_nativehyperlinktext },
+  { eCSSKeyword__moz_comboboxtext, LookAndFeel::eColorID__moz_comboboxtext },
+  { eCSSKeyword__moz_combobox, LookAndFeel::eColorID__moz_combobox },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kContentKTable[] = {
+  { eCSSKeyword_open_quote, NS_STYLE_CONTENT_OPEN_QUOTE },
+  { eCSSKeyword_close_quote, NS_STYLE_CONTENT_CLOSE_QUOTE },
+  { eCSSKeyword_no_open_quote, NS_STYLE_CONTENT_NO_OPEN_QUOTE },
+  { eCSSKeyword_no_close_quote, NS_STYLE_CONTENT_NO_CLOSE_QUOTE },
+  { eCSSKeyword__moz_alt_content, NS_STYLE_CONTENT_ALT_CONTENT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kControlCharacterVisibilityKTable[] = {
+  { eCSSKeyword_hidden, NS_STYLE_CONTROL_CHARACTER_VISIBILITY_HIDDEN },
+  { eCSSKeyword_visible, NS_STYLE_CONTROL_CHARACTER_VISIBILITY_VISIBLE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kCounterRangeKTable[] = {
+  { eCSSKeyword_infinite, NS_STYLE_COUNTER_RANGE_INFINITE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kCounterSpeakAsKTable[] = {
+  { eCSSKeyword_bullets, NS_STYLE_COUNTER_SPEAKAS_BULLETS },
+  { eCSSKeyword_numbers, NS_STYLE_COUNTER_SPEAKAS_NUMBERS },
+  { eCSSKeyword_words, NS_STYLE_COUNTER_SPEAKAS_WORDS },
+  { eCSSKeyword_spell_out, NS_STYLE_COUNTER_SPEAKAS_SPELL_OUT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kCounterSymbolsSystemKTable[] = {
+  { eCSSKeyword_cyclic, NS_STYLE_COUNTER_SYSTEM_CYCLIC },
+  { eCSSKeyword_numeric, NS_STYLE_COUNTER_SYSTEM_NUMERIC },
+  { eCSSKeyword_alphabetic, NS_STYLE_COUNTER_SYSTEM_ALPHABETIC },
+  { eCSSKeyword_symbolic, NS_STYLE_COUNTER_SYSTEM_SYMBOLIC },
+  { eCSSKeyword_fixed, NS_STYLE_COUNTER_SYSTEM_FIXED },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kCounterSystemKTable[] = {
+  { eCSSKeyword_cyclic, NS_STYLE_COUNTER_SYSTEM_CYCLIC },
+  { eCSSKeyword_numeric, NS_STYLE_COUNTER_SYSTEM_NUMERIC },
+  { eCSSKeyword_alphabetic, NS_STYLE_COUNTER_SYSTEM_ALPHABETIC },
+  { eCSSKeyword_symbolic, NS_STYLE_COUNTER_SYSTEM_SYMBOLIC },
+  { eCSSKeyword_additive, NS_STYLE_COUNTER_SYSTEM_ADDITIVE },
+  { eCSSKeyword_fixed, NS_STYLE_COUNTER_SYSTEM_FIXED },
+  { eCSSKeyword_extends, NS_STYLE_COUNTER_SYSTEM_EXTENDS },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kCursorKTable[] = {
+  // CSS 2.0
+  { eCSSKeyword_auto, NS_STYLE_CURSOR_AUTO },
+  { eCSSKeyword_crosshair, NS_STYLE_CURSOR_CROSSHAIR },
+  { eCSSKeyword_default, NS_STYLE_CURSOR_DEFAULT },
+  { eCSSKeyword_pointer, NS_STYLE_CURSOR_POINTER },
+  { eCSSKeyword_move, NS_STYLE_CURSOR_MOVE },
+  { eCSSKeyword_e_resize, NS_STYLE_CURSOR_E_RESIZE },
+  { eCSSKeyword_ne_resize, NS_STYLE_CURSOR_NE_RESIZE },
+  { eCSSKeyword_nw_resize, NS_STYLE_CURSOR_NW_RESIZE },
+  { eCSSKeyword_n_resize, NS_STYLE_CURSOR_N_RESIZE },
+  { eCSSKeyword_se_resize, NS_STYLE_CURSOR_SE_RESIZE },
+  { eCSSKeyword_sw_resize, NS_STYLE_CURSOR_SW_RESIZE },
+  { eCSSKeyword_s_resize, NS_STYLE_CURSOR_S_RESIZE },
+  { eCSSKeyword_w_resize, NS_STYLE_CURSOR_W_RESIZE },
+  { eCSSKeyword_text, NS_STYLE_CURSOR_TEXT },
+  { eCSSKeyword_wait, NS_STYLE_CURSOR_WAIT },
+  { eCSSKeyword_help, NS_STYLE_CURSOR_HELP },
+  // CSS 2.1
+  { eCSSKeyword_progress, NS_STYLE_CURSOR_SPINNING },
+  // CSS3 basic user interface module
+  { eCSSKeyword_copy, NS_STYLE_CURSOR_COPY },
+  { eCSSKeyword_alias, NS_STYLE_CURSOR_ALIAS },
+  { eCSSKeyword_context_menu, NS_STYLE_CURSOR_CONTEXT_MENU },
+  { eCSSKeyword_cell, NS_STYLE_CURSOR_CELL },
+  { eCSSKeyword_not_allowed, NS_STYLE_CURSOR_NOT_ALLOWED },
+  { eCSSKeyword_col_resize, NS_STYLE_CURSOR_COL_RESIZE },
+  { eCSSKeyword_row_resize, NS_STYLE_CURSOR_ROW_RESIZE },
+  { eCSSKeyword_no_drop, NS_STYLE_CURSOR_NO_DROP },
+  { eCSSKeyword_vertical_text, NS_STYLE_CURSOR_VERTICAL_TEXT },
+  { eCSSKeyword_all_scroll, NS_STYLE_CURSOR_ALL_SCROLL },
+  { eCSSKeyword_nesw_resize, NS_STYLE_CURSOR_NESW_RESIZE },
+  { eCSSKeyword_nwse_resize, NS_STYLE_CURSOR_NWSE_RESIZE },
+  { eCSSKeyword_ns_resize, NS_STYLE_CURSOR_NS_RESIZE },
+  { eCSSKeyword_ew_resize, NS_STYLE_CURSOR_EW_RESIZE },
+  { eCSSKeyword_none, NS_STYLE_CURSOR_NONE },
+  { eCSSKeyword_grab, NS_STYLE_CURSOR_GRAB },
+  { eCSSKeyword_grabbing, NS_STYLE_CURSOR_GRABBING },
+  { eCSSKeyword_zoom_in, NS_STYLE_CURSOR_ZOOM_IN },
+  { eCSSKeyword_zoom_out, NS_STYLE_CURSOR_ZOOM_OUT },
+  // -moz- prefixed vendor specific
+  { eCSSKeyword__moz_grab, NS_STYLE_CURSOR_GRAB },
+  { eCSSKeyword__moz_grabbing, NS_STYLE_CURSOR_GRABBING },
+  { eCSSKeyword__moz_zoom_in, NS_STYLE_CURSOR_ZOOM_IN },
+  { eCSSKeyword__moz_zoom_out, NS_STYLE_CURSOR_ZOOM_OUT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kDirectionKTable[] = {
+  { eCSSKeyword_ltr,      NS_STYLE_DIRECTION_LTR },
+  { eCSSKeyword_rtl,      NS_STYLE_DIRECTION_RTL },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+KTableEntry nsCSSProps::kDisplayKTable[] = {
+  { eCSSKeyword_none,                StyleDisplay::None },
+  { eCSSKeyword_inline,              StyleDisplay::Inline },
+  { eCSSKeyword_block,               StyleDisplay::Block },
+  { eCSSKeyword_inline_block,        StyleDisplay::InlineBlock },
+  { eCSSKeyword_list_item,           StyleDisplay::ListItem },
+  { eCSSKeyword_table,               StyleDisplay::Table },
+  { eCSSKeyword_inline_table,        StyleDisplay::InlineTable },
+  { eCSSKeyword_table_row_group,     StyleDisplay::TableRowGroup },
+  { eCSSKeyword_table_header_group,  StyleDisplay::TableHeaderGroup },
+  { eCSSKeyword_table_footer_group,  StyleDisplay::TableFooterGroup },
+  { eCSSKeyword_table_row,           StyleDisplay::TableRow },
+  { eCSSKeyword_table_column_group,  StyleDisplay::TableColumnGroup },
+  { eCSSKeyword_table_column,        StyleDisplay::TableColumn },
+  { eCSSKeyword_table_cell,          StyleDisplay::TableCell },
+  { eCSSKeyword_table_caption,       StyleDisplay::TableCaption },
+  // Make sure this is kept in sync with the code in
+  // nsCSSFrameConstructor::ConstructXULFrame
+  { eCSSKeyword__moz_box,            StyleDisplay::Box },
+  { eCSSKeyword__moz_inline_box,     StyleDisplay::InlineBox },
+#ifdef MOZ_XUL
+  { eCSSKeyword__moz_grid,           StyleDisplay::XulGrid },
+  { eCSSKeyword__moz_inline_grid,    StyleDisplay::InlineXulGrid },
+  { eCSSKeyword__moz_grid_group,     StyleDisplay::XulGridGroup },
+  { eCSSKeyword__moz_grid_line,      StyleDisplay::XulGridLine },
+  { eCSSKeyword__moz_stack,          StyleDisplay::Stack },
+  { eCSSKeyword__moz_inline_stack,   StyleDisplay::InlineStack },
+  { eCSSKeyword__moz_deck,           StyleDisplay::Deck },
+  { eCSSKeyword__moz_popup,          StyleDisplay::Popup },
+  { eCSSKeyword__moz_groupbox,       StyleDisplay::Groupbox },
+#endif
+  { eCSSKeyword_flex,                StyleDisplay::Flex },
+  { eCSSKeyword_inline_flex,         StyleDisplay::InlineFlex },
+  { eCSSKeyword_ruby,                StyleDisplay::Ruby },
+  { eCSSKeyword_ruby_base,           StyleDisplay::RubyBase },
+  { eCSSKeyword_ruby_base_container, StyleDisplay::RubyBaseContainer },
+  { eCSSKeyword_ruby_text,           StyleDisplay::RubyText },
+  { eCSSKeyword_ruby_text_container, StyleDisplay::RubyTextContainer },
+  // The next two entries are controlled by the layout.css.grid.enabled pref.
+  { eCSSKeyword_grid,                StyleDisplay::Grid },
+  { eCSSKeyword_inline_grid,         StyleDisplay::InlineGrid },
+  // The next 4 entries are controlled by the layout.css.prefixes.webkit pref.
+  { eCSSKeyword__webkit_box,         StyleDisplay::WebkitBox },
+  { eCSSKeyword__webkit_inline_box,  StyleDisplay::WebkitInlineBox },
+  { eCSSKeyword__webkit_flex,        StyleDisplay::Flex },
+  { eCSSKeyword__webkit_inline_flex, StyleDisplay::InlineFlex },
+  // The next entry is controlled by the layout.css.display-contents.enabled
+  // pref.
+  { eCSSKeyword_contents,            StyleDisplay::Contents },
+  { eCSSKeyword_UNKNOWN,             -1 }
+};
+
+const KTableEntry nsCSSProps::kEmptyCellsKTable[] = {
+  { eCSSKeyword_show,                 NS_STYLE_TABLE_EMPTY_CELLS_SHOW },
+  { eCSSKeyword_hide,                 NS_STYLE_TABLE_EMPTY_CELLS_HIDE },
+  { eCSSKeyword_UNKNOWN,              -1 }
+};
+
+const KTableEntry nsCSSProps::kAlignAllKeywords[] = {
+  { eCSSKeyword_auto,          NS_STYLE_ALIGN_AUTO },
+  { eCSSKeyword_normal,        NS_STYLE_ALIGN_NORMAL },
+  { eCSSKeyword_start,         NS_STYLE_ALIGN_START },
+  { eCSSKeyword_end,           NS_STYLE_ALIGN_END },
+  { eCSSKeyword_flex_start,    NS_STYLE_ALIGN_FLEX_START },
+  { eCSSKeyword_flex_end,      NS_STYLE_ALIGN_FLEX_END },
+  { eCSSKeyword_center,        NS_STYLE_ALIGN_CENTER },
+  { eCSSKeyword_left,          NS_STYLE_ALIGN_LEFT },
+  { eCSSKeyword_right,         NS_STYLE_ALIGN_RIGHT },
+  { eCSSKeyword_baseline,      NS_STYLE_ALIGN_BASELINE },
+  // Also "first/last baseline"; see nsCSSValue::AppendAlignJustifyValueToString
+  { eCSSKeyword_stretch,       NS_STYLE_ALIGN_STRETCH },
+  { eCSSKeyword_self_start,    NS_STYLE_ALIGN_SELF_START },
+  { eCSSKeyword_self_end,      NS_STYLE_ALIGN_SELF_END },
+  { eCSSKeyword_space_between, NS_STYLE_ALIGN_SPACE_BETWEEN },
+  { eCSSKeyword_space_around,  NS_STYLE_ALIGN_SPACE_AROUND },
+  { eCSSKeyword_space_evenly,  NS_STYLE_ALIGN_SPACE_EVENLY },
+  { eCSSKeyword_legacy,        NS_STYLE_ALIGN_LEGACY },
+  { eCSSKeyword_safe,          NS_STYLE_ALIGN_SAFE },
+  { eCSSKeyword_unsafe,        NS_STYLE_ALIGN_UNSAFE },
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+
+const KTableEntry nsCSSProps::kAlignOverflowPosition[] = {
+  { eCSSKeyword_unsafe,        NS_STYLE_ALIGN_UNSAFE },
+  { eCSSKeyword_safe,          NS_STYLE_ALIGN_SAFE },
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+
+const KTableEntry nsCSSProps::kAlignSelfPosition[] = {
+  { eCSSKeyword_start,         NS_STYLE_ALIGN_START },
+  { eCSSKeyword_end,           NS_STYLE_ALIGN_END },
+  { eCSSKeyword_flex_start,    NS_STYLE_ALIGN_FLEX_START },
+  { eCSSKeyword_flex_end,      NS_STYLE_ALIGN_FLEX_END },
+  { eCSSKeyword_center,        NS_STYLE_ALIGN_CENTER },
+  { eCSSKeyword_left,          NS_STYLE_ALIGN_LEFT },
+  { eCSSKeyword_right,         NS_STYLE_ALIGN_RIGHT },
+  { eCSSKeyword_self_start,    NS_STYLE_ALIGN_SELF_START },
+  { eCSSKeyword_self_end,      NS_STYLE_ALIGN_SELF_END },
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+
+const KTableEntry nsCSSProps::kAlignLegacy[] = {
+  { eCSSKeyword_legacy,        NS_STYLE_ALIGN_LEGACY },
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+
+const KTableEntry nsCSSProps::kAlignLegacyPosition[] = {
+  { eCSSKeyword_center,        NS_STYLE_ALIGN_CENTER },
+  { eCSSKeyword_left,          NS_STYLE_ALIGN_LEFT },
+  { eCSSKeyword_right,         NS_STYLE_ALIGN_RIGHT },
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+
+const KTableEntry nsCSSProps::kAlignAutoNormalStretchBaseline[] = {
+  { eCSSKeyword_auto,          NS_STYLE_ALIGN_AUTO },
+  { eCSSKeyword_normal,        NS_STYLE_ALIGN_NORMAL },
+  { eCSSKeyword_stretch,       NS_STYLE_ALIGN_STRETCH },
+  { eCSSKeyword_baseline,      NS_STYLE_ALIGN_BASELINE },
+  // Also "first baseline" & "last baseline"; see CSSParserImpl::ParseAlignEnum
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+
+const KTableEntry nsCSSProps::kAlignNormalStretchBaseline[] = {
+  { eCSSKeyword_normal,        NS_STYLE_ALIGN_NORMAL },
+  { eCSSKeyword_stretch,       NS_STYLE_ALIGN_STRETCH },
+  { eCSSKeyword_baseline,      NS_STYLE_ALIGN_BASELINE },
+  // Also "first baseline" & "last baseline"; see CSSParserImpl::ParseAlignEnum
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+
+const KTableEntry nsCSSProps::kAlignNormalBaseline[] = {
+  { eCSSKeyword_normal,        NS_STYLE_ALIGN_NORMAL },
+  { eCSSKeyword_baseline,      NS_STYLE_ALIGN_BASELINE },
+  // Also "first baseline" & "last baseline"; see CSSParserImpl::ParseAlignEnum
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+
+const KTableEntry nsCSSProps::kAlignContentDistribution[] = {
+  { eCSSKeyword_stretch,       NS_STYLE_ALIGN_STRETCH },
+  { eCSSKeyword_space_between, NS_STYLE_ALIGN_SPACE_BETWEEN },
+  { eCSSKeyword_space_around,  NS_STYLE_ALIGN_SPACE_AROUND },
+  { eCSSKeyword_space_evenly,  NS_STYLE_ALIGN_SPACE_EVENLY },
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+
+const KTableEntry nsCSSProps::kAlignContentPosition[] = {
+  { eCSSKeyword_start,         NS_STYLE_ALIGN_START },
+  { eCSSKeyword_end,           NS_STYLE_ALIGN_END },
+  { eCSSKeyword_flex_start,    NS_STYLE_ALIGN_FLEX_START },
+  { eCSSKeyword_flex_end,      NS_STYLE_ALIGN_FLEX_END },
+  { eCSSKeyword_center,        NS_STYLE_ALIGN_CENTER },
+  { eCSSKeyword_left,          NS_STYLE_ALIGN_LEFT },
+  { eCSSKeyword_right,         NS_STYLE_ALIGN_RIGHT },
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+
+// <NOTE> these are only used for auto-completion, not parsing:
+const KTableEntry nsCSSProps::kAutoCompletionAlignJustifySelf[] = {
+  { eCSSKeyword_auto,          NS_STYLE_ALIGN_AUTO },
+  { eCSSKeyword_normal,        NS_STYLE_ALIGN_NORMAL },
+  { eCSSKeyword_stretch,       NS_STYLE_ALIGN_STRETCH },
+  { eCSSKeyword_baseline,      NS_STYLE_ALIGN_BASELINE },
+  { eCSSKeyword_last_baseline, NS_STYLE_ALIGN_LAST_BASELINE },
+  { eCSSKeyword_start,         NS_STYLE_ALIGN_START },
+  { eCSSKeyword_end,           NS_STYLE_ALIGN_END },
+  { eCSSKeyword_flex_start,    NS_STYLE_ALIGN_FLEX_START },
+  { eCSSKeyword_flex_end,      NS_STYLE_ALIGN_FLEX_END },
+  { eCSSKeyword_center,        NS_STYLE_ALIGN_CENTER },
+  { eCSSKeyword_left,          NS_STYLE_ALIGN_LEFT },
+  { eCSSKeyword_right,         NS_STYLE_ALIGN_RIGHT },
+  { eCSSKeyword_self_start,    NS_STYLE_ALIGN_SELF_START },
+  { eCSSKeyword_self_end,      NS_STYLE_ALIGN_SELF_END },
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+
+const KTableEntry nsCSSProps::kAutoCompletionAlignItems[] = {
+  // Intentionally no 'auto' here.
+  { eCSSKeyword_normal,        NS_STYLE_ALIGN_NORMAL },
+  { eCSSKeyword_stretch,       NS_STYLE_ALIGN_STRETCH },
+  { eCSSKeyword_baseline,      NS_STYLE_ALIGN_BASELINE },
+  { eCSSKeyword_last_baseline, NS_STYLE_ALIGN_LAST_BASELINE },
+  { eCSSKeyword_start,         NS_STYLE_ALIGN_START },
+  { eCSSKeyword_end,           NS_STYLE_ALIGN_END },
+  { eCSSKeyword_flex_start,    NS_STYLE_ALIGN_FLEX_START },
+  { eCSSKeyword_flex_end,      NS_STYLE_ALIGN_FLEX_END },
+  { eCSSKeyword_center,        NS_STYLE_ALIGN_CENTER },
+  { eCSSKeyword_left,          NS_STYLE_ALIGN_LEFT },
+  { eCSSKeyword_right,         NS_STYLE_ALIGN_RIGHT },
+  { eCSSKeyword_self_start,    NS_STYLE_ALIGN_SELF_START },
+  { eCSSKeyword_self_end,      NS_STYLE_ALIGN_SELF_END },
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+
+const KTableEntry nsCSSProps::kAutoCompletionAlignJustifyContent[] = {
+  // Intentionally no 'auto' here.
+  { eCSSKeyword_normal,        NS_STYLE_ALIGN_NORMAL },
+  { eCSSKeyword_baseline,      NS_STYLE_ALIGN_BASELINE },
+  { eCSSKeyword_last_baseline, NS_STYLE_ALIGN_LAST_BASELINE },
+  { eCSSKeyword_stretch,       NS_STYLE_ALIGN_STRETCH },
+  { eCSSKeyword_space_between, NS_STYLE_ALIGN_SPACE_BETWEEN },
+  { eCSSKeyword_space_around,  NS_STYLE_ALIGN_SPACE_AROUND },
+  { eCSSKeyword_space_evenly,  NS_STYLE_ALIGN_SPACE_EVENLY },
+  { eCSSKeyword_start,         NS_STYLE_ALIGN_START },
+  { eCSSKeyword_end,           NS_STYLE_ALIGN_END },
+  { eCSSKeyword_flex_start,    NS_STYLE_ALIGN_FLEX_START },
+  { eCSSKeyword_flex_end,      NS_STYLE_ALIGN_FLEX_END },
+  { eCSSKeyword_center,        NS_STYLE_ALIGN_CENTER },
+  { eCSSKeyword_left,          NS_STYLE_ALIGN_LEFT },
+  { eCSSKeyword_right,         NS_STYLE_ALIGN_RIGHT },
+  { eCSSKeyword_UNKNOWN,       -1 }
+};
+// </NOTE>
+
+const KTableEntry nsCSSProps::kFlexDirectionKTable[] = {
+  { eCSSKeyword_row,            NS_STYLE_FLEX_DIRECTION_ROW },
+  { eCSSKeyword_row_reverse,    NS_STYLE_FLEX_DIRECTION_ROW_REVERSE },
+  { eCSSKeyword_column,         NS_STYLE_FLEX_DIRECTION_COLUMN },
+  { eCSSKeyword_column_reverse, NS_STYLE_FLEX_DIRECTION_COLUMN_REVERSE },
+  { eCSSKeyword_UNKNOWN,        -1 }
+};
+
+const KTableEntry nsCSSProps::kFlexWrapKTable[] = {
+  { eCSSKeyword_nowrap,       NS_STYLE_FLEX_WRAP_NOWRAP },
+  { eCSSKeyword_wrap,         NS_STYLE_FLEX_WRAP_WRAP },
+  { eCSSKeyword_wrap_reverse, NS_STYLE_FLEX_WRAP_WRAP_REVERSE },
+  { eCSSKeyword_UNKNOWN,      -1 }
+};
+
+const KTableEntry nsCSSProps::kHyphensKTable[] = {
+  { eCSSKeyword_none, NS_STYLE_HYPHENS_NONE },
+  { eCSSKeyword_manual, NS_STYLE_HYPHENS_MANUAL },
+  { eCSSKeyword_auto, NS_STYLE_HYPHENS_AUTO },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+KTableEntry nsCSSProps::kFloatKTable[] = {
+  { eCSSKeyword_none, StyleFloat::None },
+  { eCSSKeyword_left, StyleFloat::Left },
+  { eCSSKeyword_right, StyleFloat::Right },
+  { eCSSKeyword_inline_start, StyleFloat::InlineStart },
+  { eCSSKeyword_inline_end, StyleFloat::InlineEnd },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFloatEdgeKTable[] = {
+  { eCSSKeyword_content_box, uint8_t(StyleFloatEdge::ContentBox) },
+  { eCSSKeyword_margin_box, uint8_t(StyleFloatEdge::MarginBox) },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontDisplayKTable[] = {
+  { eCSSKeyword_auto, NS_FONT_DISPLAY_AUTO },
+  { eCSSKeyword_block, NS_FONT_DISPLAY_BLOCK },
+  { eCSSKeyword_swap, NS_FONT_DISPLAY_SWAP },
+  { eCSSKeyword_fallback, NS_FONT_DISPLAY_FALLBACK },
+  { eCSSKeyword_optional, NS_FONT_DISPLAY_OPTIONAL },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontKTable[] = {
+  // CSS2.
+  { eCSSKeyword_caption, NS_STYLE_FONT_CAPTION },
+  { eCSSKeyword_icon, NS_STYLE_FONT_ICON },
+  { eCSSKeyword_menu, NS_STYLE_FONT_MENU },
+  { eCSSKeyword_message_box, NS_STYLE_FONT_MESSAGE_BOX },
+  { eCSSKeyword_small_caption, NS_STYLE_FONT_SMALL_CAPTION },
+  { eCSSKeyword_status_bar, NS_STYLE_FONT_STATUS_BAR },
+
+  // Proposed for CSS3.
+  { eCSSKeyword__moz_window, NS_STYLE_FONT_WINDOW },
+  { eCSSKeyword__moz_document, NS_STYLE_FONT_DOCUMENT },
+  { eCSSKeyword__moz_workspace, NS_STYLE_FONT_WORKSPACE },
+  { eCSSKeyword__moz_desktop, NS_STYLE_FONT_DESKTOP },
+  { eCSSKeyword__moz_info, NS_STYLE_FONT_INFO },
+  { eCSSKeyword__moz_dialog, NS_STYLE_FONT_DIALOG },
+  { eCSSKeyword__moz_button, NS_STYLE_FONT_BUTTON },
+  { eCSSKeyword__moz_pull_down_menu, NS_STYLE_FONT_PULL_DOWN_MENU },
+  { eCSSKeyword__moz_list, NS_STYLE_FONT_LIST },
+  { eCSSKeyword__moz_field, NS_STYLE_FONT_FIELD },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontKerningKTable[] = {
+  { eCSSKeyword_auto, NS_FONT_KERNING_AUTO },
+  { eCSSKeyword_none, NS_FONT_KERNING_NONE },
+  { eCSSKeyword_normal, NS_FONT_KERNING_NORMAL },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontSizeKTable[] = {
+  { eCSSKeyword_xx_small, NS_STYLE_FONT_SIZE_XXSMALL },
+  { eCSSKeyword_x_small, NS_STYLE_FONT_SIZE_XSMALL },
+  { eCSSKeyword_small, NS_STYLE_FONT_SIZE_SMALL },
+  { eCSSKeyword_medium, NS_STYLE_FONT_SIZE_MEDIUM },
+  { eCSSKeyword_large, NS_STYLE_FONT_SIZE_LARGE },
+  { eCSSKeyword_x_large, NS_STYLE_FONT_SIZE_XLARGE },
+  { eCSSKeyword_xx_large, NS_STYLE_FONT_SIZE_XXLARGE },
+  { eCSSKeyword_larger, NS_STYLE_FONT_SIZE_LARGER },
+  { eCSSKeyword_smaller, NS_STYLE_FONT_SIZE_SMALLER },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontSmoothingKTable[] = {
+  { eCSSKeyword_auto, NS_FONT_SMOOTHING_AUTO },
+  { eCSSKeyword_grayscale, NS_FONT_SMOOTHING_GRAYSCALE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontStretchKTable[] = {
+  { eCSSKeyword_ultra_condensed, NS_STYLE_FONT_STRETCH_ULTRA_CONDENSED },
+  { eCSSKeyword_extra_condensed, NS_STYLE_FONT_STRETCH_EXTRA_CONDENSED },
+  { eCSSKeyword_condensed, NS_STYLE_FONT_STRETCH_CONDENSED },
+  { eCSSKeyword_semi_condensed, NS_STYLE_FONT_STRETCH_SEMI_CONDENSED },
+  { eCSSKeyword_normal, NS_STYLE_FONT_STRETCH_NORMAL },
+  { eCSSKeyword_semi_expanded, NS_STYLE_FONT_STRETCH_SEMI_EXPANDED },
+  { eCSSKeyword_expanded, NS_STYLE_FONT_STRETCH_EXPANDED },
+  { eCSSKeyword_extra_expanded, NS_STYLE_FONT_STRETCH_EXTRA_EXPANDED },
+  { eCSSKeyword_ultra_expanded, NS_STYLE_FONT_STRETCH_ULTRA_EXPANDED },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontStyleKTable[] = {
+  { eCSSKeyword_normal, NS_STYLE_FONT_STYLE_NORMAL },
+  { eCSSKeyword_italic, NS_STYLE_FONT_STYLE_ITALIC },
+  { eCSSKeyword_oblique, NS_STYLE_FONT_STYLE_OBLIQUE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontSynthesisKTable[] = {
+  { eCSSKeyword_weight, NS_FONT_SYNTHESIS_WEIGHT },
+  { eCSSKeyword_style, NS_FONT_SYNTHESIS_STYLE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontVariantAlternatesKTable[] = {
+  { eCSSKeyword_historical_forms, NS_FONT_VARIANT_ALTERNATES_HISTORICAL },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontVariantAlternatesFuncsKTable[] = {
+  { eCSSKeyword_stylistic, NS_FONT_VARIANT_ALTERNATES_STYLISTIC },
+  { eCSSKeyword_styleset, NS_FONT_VARIANT_ALTERNATES_STYLESET },
+  { eCSSKeyword_character_variant, NS_FONT_VARIANT_ALTERNATES_CHARACTER_VARIANT },
+  { eCSSKeyword_swash, NS_FONT_VARIANT_ALTERNATES_SWASH },
+  { eCSSKeyword_ornaments, NS_FONT_VARIANT_ALTERNATES_ORNAMENTS },
+  { eCSSKeyword_annotation, NS_FONT_VARIANT_ALTERNATES_ANNOTATION },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontVariantCapsKTable[] = {
+  { eCSSKeyword_small_caps, NS_FONT_VARIANT_CAPS_SMALLCAPS },
+  { eCSSKeyword_all_small_caps, NS_FONT_VARIANT_CAPS_ALLSMALL },
+  { eCSSKeyword_petite_caps, NS_FONT_VARIANT_CAPS_PETITECAPS },
+  { eCSSKeyword_all_petite_caps, NS_FONT_VARIANT_CAPS_ALLPETITE },
+  { eCSSKeyword_titling_caps, NS_FONT_VARIANT_CAPS_TITLING },
+  { eCSSKeyword_unicase, NS_FONT_VARIANT_CAPS_UNICASE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontVariantEastAsianKTable[] = {
+  { eCSSKeyword_jis78, NS_FONT_VARIANT_EAST_ASIAN_JIS78 },
+  { eCSSKeyword_jis83, NS_FONT_VARIANT_EAST_ASIAN_JIS83 },
+  { eCSSKeyword_jis90, NS_FONT_VARIANT_EAST_ASIAN_JIS90 },
+  { eCSSKeyword_jis04, NS_FONT_VARIANT_EAST_ASIAN_JIS04 },
+  { eCSSKeyword_simplified, NS_FONT_VARIANT_EAST_ASIAN_SIMPLIFIED },
+  { eCSSKeyword_traditional, NS_FONT_VARIANT_EAST_ASIAN_TRADITIONAL },
+  { eCSSKeyword_full_width, NS_FONT_VARIANT_EAST_ASIAN_FULL_WIDTH },
+  { eCSSKeyword_proportional_width, NS_FONT_VARIANT_EAST_ASIAN_PROP_WIDTH },
+  { eCSSKeyword_ruby, NS_FONT_VARIANT_EAST_ASIAN_RUBY },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontVariantLigaturesKTable[] = {
+  { eCSSKeyword_common_ligatures, NS_FONT_VARIANT_LIGATURES_COMMON },
+  { eCSSKeyword_no_common_ligatures, NS_FONT_VARIANT_LIGATURES_NO_COMMON },
+  { eCSSKeyword_discretionary_ligatures, NS_FONT_VARIANT_LIGATURES_DISCRETIONARY },
+  { eCSSKeyword_no_discretionary_ligatures, NS_FONT_VARIANT_LIGATURES_NO_DISCRETIONARY },
+  { eCSSKeyword_historical_ligatures, NS_FONT_VARIANT_LIGATURES_HISTORICAL },
+  { eCSSKeyword_no_historical_ligatures, NS_FONT_VARIANT_LIGATURES_NO_HISTORICAL },
+  { eCSSKeyword_contextual, NS_FONT_VARIANT_LIGATURES_CONTEXTUAL },
+  { eCSSKeyword_no_contextual, NS_FONT_VARIANT_LIGATURES_NO_CONTEXTUAL },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontVariantNumericKTable[] = {
+  { eCSSKeyword_lining_nums, NS_FONT_VARIANT_NUMERIC_LINING },
+  { eCSSKeyword_oldstyle_nums, NS_FONT_VARIANT_NUMERIC_OLDSTYLE },
+  { eCSSKeyword_proportional_nums, NS_FONT_VARIANT_NUMERIC_PROPORTIONAL },
+  { eCSSKeyword_tabular_nums, NS_FONT_VARIANT_NUMERIC_TABULAR },
+  { eCSSKeyword_diagonal_fractions, NS_FONT_VARIANT_NUMERIC_DIAGONAL_FRACTIONS },
+  { eCSSKeyword_stacked_fractions, NS_FONT_VARIANT_NUMERIC_STACKED_FRACTIONS },
+  { eCSSKeyword_slashed_zero, NS_FONT_VARIANT_NUMERIC_SLASHZERO },
+  { eCSSKeyword_ordinal, NS_FONT_VARIANT_NUMERIC_ORDINAL },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontVariantPositionKTable[] = {
+  { eCSSKeyword_super, NS_FONT_VARIANT_POSITION_SUPER },
+  { eCSSKeyword_sub, NS_FONT_VARIANT_POSITION_SUB },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFontWeightKTable[] = {
+  { eCSSKeyword_normal, NS_STYLE_FONT_WEIGHT_NORMAL },
+  { eCSSKeyword_bold, NS_STYLE_FONT_WEIGHT_BOLD },
+  { eCSSKeyword_bolder, NS_STYLE_FONT_WEIGHT_BOLDER },
+  { eCSSKeyword_lighter, NS_STYLE_FONT_WEIGHT_LIGHTER },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kGridAutoFlowKTable[] = {
+  { eCSSKeyword_row, NS_STYLE_GRID_AUTO_FLOW_ROW },
+  { eCSSKeyword_column, NS_STYLE_GRID_AUTO_FLOW_COLUMN },
+  { eCSSKeyword_dense, NS_STYLE_GRID_AUTO_FLOW_DENSE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kGridTrackBreadthKTable[] = {
+  { eCSSKeyword_min_content, NS_STYLE_GRID_TRACK_BREADTH_MIN_CONTENT },
+  { eCSSKeyword_max_content, NS_STYLE_GRID_TRACK_BREADTH_MAX_CONTENT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kImageOrientationKTable[] = {
+  { eCSSKeyword_flip, NS_STYLE_IMAGE_ORIENTATION_FLIP },
+  { eCSSKeyword_from_image, NS_STYLE_IMAGE_ORIENTATION_FROM_IMAGE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kImageOrientationFlipKTable[] = {
+  { eCSSKeyword_flip, NS_STYLE_IMAGE_ORIENTATION_FLIP },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kIsolationKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_ISOLATION_AUTO },
+  { eCSSKeyword_isolate, NS_STYLE_ISOLATION_ISOLATE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kIMEModeKTable[] = {
+  { eCSSKeyword_normal, NS_STYLE_IME_MODE_NORMAL },
+  { eCSSKeyword_auto, NS_STYLE_IME_MODE_AUTO },
+  { eCSSKeyword_active, NS_STYLE_IME_MODE_ACTIVE },
+  { eCSSKeyword_disabled, NS_STYLE_IME_MODE_DISABLED },
+  { eCSSKeyword_inactive, NS_STYLE_IME_MODE_INACTIVE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kLineHeightKTable[] = {
+  // -moz- prefixed, intended for internal use for single-line controls
+  { eCSSKeyword__moz_block_height, NS_STYLE_LINE_HEIGHT_BLOCK_HEIGHT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kListStylePositionKTable[] = {
+  { eCSSKeyword_inside, NS_STYLE_LIST_STYLE_POSITION_INSIDE },
+  { eCSSKeyword_outside, NS_STYLE_LIST_STYLE_POSITION_OUTSIDE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kListStyleKTable[] = {
+  // none and decimal are not redefinable, so they should not be moved.
+  { eCSSKeyword_none, NS_STYLE_LIST_STYLE_NONE },
+  { eCSSKeyword_decimal, NS_STYLE_LIST_STYLE_DECIMAL },
+  // the following graphic styles are processed in a different way.
+  { eCSSKeyword_disc, NS_STYLE_LIST_STYLE_DISC },
+  { eCSSKeyword_circle, NS_STYLE_LIST_STYLE_CIRCLE },
+  { eCSSKeyword_square, NS_STYLE_LIST_STYLE_SQUARE },
+  { eCSSKeyword_disclosure_closed, NS_STYLE_LIST_STYLE_DISCLOSURE_CLOSED },
+  { eCSSKeyword_disclosure_open, NS_STYLE_LIST_STYLE_DISCLOSURE_OPEN },
+  // the following counter styles require specific algorithms to generate.
+  { eCSSKeyword_hebrew, NS_STYLE_LIST_STYLE_HEBREW },
+  { eCSSKeyword_japanese_informal, NS_STYLE_LIST_STYLE_JAPANESE_INFORMAL },
+  { eCSSKeyword_japanese_formal, NS_STYLE_LIST_STYLE_JAPANESE_FORMAL },
+  { eCSSKeyword_korean_hangul_formal, NS_STYLE_LIST_STYLE_KOREAN_HANGUL_FORMAL },
+  { eCSSKeyword_korean_hanja_informal, NS_STYLE_LIST_STYLE_KOREAN_HANJA_INFORMAL },
+  { eCSSKeyword_korean_hanja_formal, NS_STYLE_LIST_STYLE_KOREAN_HANJA_FORMAL },
+  { eCSSKeyword_simp_chinese_informal, NS_STYLE_LIST_STYLE_SIMP_CHINESE_INFORMAL },
+  { eCSSKeyword_simp_chinese_formal, NS_STYLE_LIST_STYLE_SIMP_CHINESE_FORMAL },
+  { eCSSKeyword_trad_chinese_informal, NS_STYLE_LIST_STYLE_TRAD_CHINESE_INFORMAL },
+  { eCSSKeyword_trad_chinese_formal, NS_STYLE_LIST_STYLE_TRAD_CHINESE_FORMAL },
+  { eCSSKeyword_ethiopic_numeric, NS_STYLE_LIST_STYLE_ETHIOPIC_NUMERIC },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kMathVariantKTable[] = {
+  { eCSSKeyword_none, NS_MATHML_MATHVARIANT_NONE },
+  { eCSSKeyword_normal, NS_MATHML_MATHVARIANT_NORMAL },
+  { eCSSKeyword_bold, NS_MATHML_MATHVARIANT_BOLD },
+  { eCSSKeyword_italic, NS_MATHML_MATHVARIANT_ITALIC },
+  { eCSSKeyword_bold_italic, NS_MATHML_MATHVARIANT_BOLD_ITALIC },
+  { eCSSKeyword_script, NS_MATHML_MATHVARIANT_SCRIPT },
+  { eCSSKeyword_bold_script, NS_MATHML_MATHVARIANT_BOLD_SCRIPT },
+  { eCSSKeyword_fraktur, NS_MATHML_MATHVARIANT_FRAKTUR },
+  { eCSSKeyword_double_struck, NS_MATHML_MATHVARIANT_DOUBLE_STRUCK },
+  { eCSSKeyword_bold_fraktur, NS_MATHML_MATHVARIANT_BOLD_FRAKTUR },
+  { eCSSKeyword_sans_serif, NS_MATHML_MATHVARIANT_SANS_SERIF },
+  { eCSSKeyword_bold_sans_serif, NS_MATHML_MATHVARIANT_BOLD_SANS_SERIF },
+  { eCSSKeyword_sans_serif_italic, NS_MATHML_MATHVARIANT_SANS_SERIF_ITALIC },
+  { eCSSKeyword_sans_serif_bold_italic, NS_MATHML_MATHVARIANT_SANS_SERIF_BOLD_ITALIC },
+  { eCSSKeyword_monospace, NS_MATHML_MATHVARIANT_MONOSPACE },
+  { eCSSKeyword_initial, NS_MATHML_MATHVARIANT_INITIAL },
+  { eCSSKeyword_tailed, NS_MATHML_MATHVARIANT_TAILED },
+  { eCSSKeyword_looped, NS_MATHML_MATHVARIANT_LOOPED },
+  { eCSSKeyword_stretched, NS_MATHML_MATHVARIANT_STRETCHED },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kMathDisplayKTable[] = {
+  { eCSSKeyword_inline, NS_MATHML_DISPLAYSTYLE_INLINE },
+  { eCSSKeyword_block, NS_MATHML_DISPLAYSTYLE_BLOCK },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kContainKTable[] = {
+  { eCSSKeyword_none,    NS_STYLE_CONTAIN_NONE },
+  { eCSSKeyword_strict,  NS_STYLE_CONTAIN_STRICT },
+  { eCSSKeyword_layout,  NS_STYLE_CONTAIN_LAYOUT },
+  { eCSSKeyword_style,   NS_STYLE_CONTAIN_STYLE },
+  { eCSSKeyword_paint,   NS_STYLE_CONTAIN_PAINT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kContextOpacityKTable[] = {
+  { eCSSKeyword_context_fill_opacity, NS_STYLE_CONTEXT_FILL_OPACITY },
+  { eCSSKeyword_context_stroke_opacity, NS_STYLE_CONTEXT_STROKE_OPACITY },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kContextPatternKTable[] = {
+  { eCSSKeyword_context_fill, NS_COLOR_CONTEXT_FILL },
+  { eCSSKeyword_context_stroke, NS_COLOR_CONTEXT_STROKE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kObjectFitKTable[] = {
+  { eCSSKeyword_fill,       NS_STYLE_OBJECT_FIT_FILL },
+  { eCSSKeyword_contain,    NS_STYLE_OBJECT_FIT_CONTAIN },
+  { eCSSKeyword_cover,      NS_STYLE_OBJECT_FIT_COVER },
+  { eCSSKeyword_none,       NS_STYLE_OBJECT_FIT_NONE },
+  { eCSSKeyword_scale_down, NS_STYLE_OBJECT_FIT_SCALE_DOWN },
+  { eCSSKeyword_UNKNOWN,    -1 }
+};
+
+const KTableEntry nsCSSProps::kOrientKTable[] = {
+  { eCSSKeyword_inline,     StyleOrient::Inline },
+  { eCSSKeyword_block,      StyleOrient::Block },
+  { eCSSKeyword_horizontal, StyleOrient::Horizontal },
+  { eCSSKeyword_vertical,   StyleOrient::Vertical },
+  { eCSSKeyword_UNKNOWN,    -1 }
+};
+
+// Same as kBorderStyleKTable except 'hidden'.
+const KTableEntry nsCSSProps::kOutlineStyleKTable[] = {
+  { eCSSKeyword_none,   NS_STYLE_BORDER_STYLE_NONE },
+  { eCSSKeyword_auto,   NS_STYLE_BORDER_STYLE_AUTO },
+  { eCSSKeyword_dotted, NS_STYLE_BORDER_STYLE_DOTTED },
+  { eCSSKeyword_dashed, NS_STYLE_BORDER_STYLE_DASHED },
+  { eCSSKeyword_solid,  NS_STYLE_BORDER_STYLE_SOLID },
+  { eCSSKeyword_double, NS_STYLE_BORDER_STYLE_DOUBLE },
+  { eCSSKeyword_groove, NS_STYLE_BORDER_STYLE_GROOVE },
+  { eCSSKeyword_ridge,  NS_STYLE_BORDER_STYLE_RIDGE },
+  { eCSSKeyword_inset,  NS_STYLE_BORDER_STYLE_INSET },
+  { eCSSKeyword_outset, NS_STYLE_BORDER_STYLE_OUTSET },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kOverflowKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_OVERFLOW_AUTO },
+  { eCSSKeyword_visible, NS_STYLE_OVERFLOW_VISIBLE },
+  { eCSSKeyword_hidden, NS_STYLE_OVERFLOW_HIDDEN },
+  { eCSSKeyword_scroll, NS_STYLE_OVERFLOW_SCROLL },
+  // Deprecated:
+  { eCSSKeyword__moz_scrollbars_none, NS_STYLE_OVERFLOW_HIDDEN },
+  { eCSSKeyword__moz_scrollbars_horizontal, NS_STYLE_OVERFLOW_SCROLLBARS_HORIZONTAL },
+  { eCSSKeyword__moz_scrollbars_vertical, NS_STYLE_OVERFLOW_SCROLLBARS_VERTICAL },
+  { eCSSKeyword__moz_hidden_unscrollable, NS_STYLE_OVERFLOW_CLIP },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kOverflowClipBoxKTable[] = {
+  { eCSSKeyword_padding_box, NS_STYLE_OVERFLOW_CLIP_BOX_PADDING_BOX },
+  { eCSSKeyword_content_box, NS_STYLE_OVERFLOW_CLIP_BOX_CONTENT_BOX },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kOverflowSubKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_OVERFLOW_AUTO },
+  { eCSSKeyword_visible, NS_STYLE_OVERFLOW_VISIBLE },
+  { eCSSKeyword_hidden, NS_STYLE_OVERFLOW_HIDDEN },
+  { eCSSKeyword_scroll, NS_STYLE_OVERFLOW_SCROLL },
+  // Deprecated:
+  { eCSSKeyword__moz_hidden_unscrollable, NS_STYLE_OVERFLOW_CLIP },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kPageBreakKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_PAGE_BREAK_AUTO },
+  { eCSSKeyword_always, NS_STYLE_PAGE_BREAK_ALWAYS },
+  { eCSSKeyword_avoid, NS_STYLE_PAGE_BREAK_AVOID },
+  { eCSSKeyword_left, NS_STYLE_PAGE_BREAK_LEFT },
+  { eCSSKeyword_right, NS_STYLE_PAGE_BREAK_RIGHT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kPageBreakInsideKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_PAGE_BREAK_AUTO },
+  { eCSSKeyword_avoid, NS_STYLE_PAGE_BREAK_AVOID },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kPageMarksKTable[] = {
+  { eCSSKeyword_none, NS_STYLE_PAGE_MARKS_NONE },
+  { eCSSKeyword_crop, NS_STYLE_PAGE_MARKS_CROP },
+  { eCSSKeyword_cross, NS_STYLE_PAGE_MARKS_REGISTER },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kPageSizeKTable[] = {
+  { eCSSKeyword_landscape, NS_STYLE_PAGE_SIZE_LANDSCAPE },
+  { eCSSKeyword_portrait, NS_STYLE_PAGE_SIZE_PORTRAIT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kPointerEventsKTable[] = {
+  { eCSSKeyword_none, NS_STYLE_POINTER_EVENTS_NONE },
+  { eCSSKeyword_visiblepainted, NS_STYLE_POINTER_EVENTS_VISIBLEPAINTED },
+  { eCSSKeyword_visiblefill, NS_STYLE_POINTER_EVENTS_VISIBLEFILL },
+  { eCSSKeyword_visiblestroke, NS_STYLE_POINTER_EVENTS_VISIBLESTROKE },
+  { eCSSKeyword_visible, NS_STYLE_POINTER_EVENTS_VISIBLE },
+  { eCSSKeyword_painted, NS_STYLE_POINTER_EVENTS_PAINTED },
+  { eCSSKeyword_fill, NS_STYLE_POINTER_EVENTS_FILL },
+  { eCSSKeyword_stroke, NS_STYLE_POINTER_EVENTS_STROKE },
+  { eCSSKeyword_all, NS_STYLE_POINTER_EVENTS_ALL },
+  { eCSSKeyword_auto, NS_STYLE_POINTER_EVENTS_AUTO },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kPositionKTable[] = {
+  { eCSSKeyword_static, NS_STYLE_POSITION_STATIC },
+  { eCSSKeyword_relative, NS_STYLE_POSITION_RELATIVE },
+  { eCSSKeyword_absolute, NS_STYLE_POSITION_ABSOLUTE },
+  { eCSSKeyword_fixed, NS_STYLE_POSITION_FIXED },
+  { eCSSKeyword_sticky, NS_STYLE_POSITION_STICKY },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kRadialGradientShapeKTable[] = {
+  { eCSSKeyword_circle,  NS_STYLE_GRADIENT_SHAPE_CIRCULAR },
+  { eCSSKeyword_ellipse, NS_STYLE_GRADIENT_SHAPE_ELLIPTICAL },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kRadialGradientSizeKTable[] = {
+  { eCSSKeyword_closest_side,    NS_STYLE_GRADIENT_SIZE_CLOSEST_SIDE },
+  { eCSSKeyword_closest_corner,  NS_STYLE_GRADIENT_SIZE_CLOSEST_CORNER },
+  { eCSSKeyword_farthest_side,   NS_STYLE_GRADIENT_SIZE_FARTHEST_SIDE },
+  { eCSSKeyword_farthest_corner, NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER },
+  { eCSSKeyword_UNKNOWN,         -1 }
+};
+
+const KTableEntry nsCSSProps::kRadialGradientLegacySizeKTable[] = {
+  { eCSSKeyword_closest_side,    NS_STYLE_GRADIENT_SIZE_CLOSEST_SIDE },
+  { eCSSKeyword_closest_corner,  NS_STYLE_GRADIENT_SIZE_CLOSEST_CORNER },
+  { eCSSKeyword_farthest_side,   NS_STYLE_GRADIENT_SIZE_FARTHEST_SIDE },
+  { eCSSKeyword_farthest_corner, NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER },
+  // synonyms
+  { eCSSKeyword_contain,         NS_STYLE_GRADIENT_SIZE_CLOSEST_SIDE },
+  { eCSSKeyword_cover,           NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER },
+  { eCSSKeyword_UNKNOWN,         -1 }
+};
+
+const KTableEntry nsCSSProps::kResizeKTable[] = {
+  { eCSSKeyword_none,       NS_STYLE_RESIZE_NONE },
+  { eCSSKeyword_both,       NS_STYLE_RESIZE_BOTH },
+  { eCSSKeyword_horizontal, NS_STYLE_RESIZE_HORIZONTAL },
+  { eCSSKeyword_vertical,   NS_STYLE_RESIZE_VERTICAL },
+  { eCSSKeyword_UNKNOWN,    -1 }
+};
+
+const KTableEntry nsCSSProps::kRubyAlignKTable[] = {
+  { eCSSKeyword_start, NS_STYLE_RUBY_ALIGN_START },
+  { eCSSKeyword_center, NS_STYLE_RUBY_ALIGN_CENTER },
+  { eCSSKeyword_space_between, NS_STYLE_RUBY_ALIGN_SPACE_BETWEEN },
+  { eCSSKeyword_space_around, NS_STYLE_RUBY_ALIGN_SPACE_AROUND },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kRubyPositionKTable[] = {
+  { eCSSKeyword_over, NS_STYLE_RUBY_POSITION_OVER },
+  { eCSSKeyword_under, NS_STYLE_RUBY_POSITION_UNDER },
+  // bug 1055672 for 'inter-character' support
+  // { eCSSKeyword_inter_character, NS_STYLE_RUBY_POSITION_INTER_CHARACTER },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kScrollBehaviorKTable[] = {
+  { eCSSKeyword_auto,       NS_STYLE_SCROLL_BEHAVIOR_AUTO },
+  { eCSSKeyword_smooth,     NS_STYLE_SCROLL_BEHAVIOR_SMOOTH },
+  { eCSSKeyword_UNKNOWN,    -1 }
+};
+
+const KTableEntry nsCSSProps::kScrollSnapTypeKTable[] = {
+  { eCSSKeyword_none,      NS_STYLE_SCROLL_SNAP_TYPE_NONE },
+  { eCSSKeyword_mandatory, NS_STYLE_SCROLL_SNAP_TYPE_MANDATORY },
+  { eCSSKeyword_proximity, NS_STYLE_SCROLL_SNAP_TYPE_PROXIMITY },
+  { eCSSKeyword_UNKNOWN,   -1 }
+};
+
+const KTableEntry nsCSSProps::kStackSizingKTable[] = {
+  { eCSSKeyword_ignore, NS_STYLE_STACK_SIZING_IGNORE },
+  { eCSSKeyword_stretch_to_fit, NS_STYLE_STACK_SIZING_STRETCH_TO_FIT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTableLayoutKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_TABLE_LAYOUT_AUTO },
+  { eCSSKeyword_fixed, NS_STYLE_TABLE_LAYOUT_FIXED },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+KTableEntry nsCSSProps::kTextAlignKTable[] = {
+  { eCSSKeyword_left, NS_STYLE_TEXT_ALIGN_LEFT },
+  { eCSSKeyword_right, NS_STYLE_TEXT_ALIGN_RIGHT },
+  { eCSSKeyword_center, NS_STYLE_TEXT_ALIGN_CENTER },
+  { eCSSKeyword_justify, NS_STYLE_TEXT_ALIGN_JUSTIFY },
+  { eCSSKeyword__moz_center, NS_STYLE_TEXT_ALIGN_MOZ_CENTER },
+  { eCSSKeyword__moz_right, NS_STYLE_TEXT_ALIGN_MOZ_RIGHT },
+  { eCSSKeyword__moz_left, NS_STYLE_TEXT_ALIGN_MOZ_LEFT },
+  { eCSSKeyword_start, NS_STYLE_TEXT_ALIGN_START },
+  { eCSSKeyword_end, NS_STYLE_TEXT_ALIGN_END },
+  { eCSSKeyword_unsafe, NS_STYLE_TEXT_ALIGN_UNSAFE },
+  { eCSSKeyword_match_parent, NS_STYLE_TEXT_ALIGN_MATCH_PARENT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+KTableEntry nsCSSProps::kTextAlignLastKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_TEXT_ALIGN_AUTO },
+  { eCSSKeyword_left, NS_STYLE_TEXT_ALIGN_LEFT },
+  { eCSSKeyword_right, NS_STYLE_TEXT_ALIGN_RIGHT },
+  { eCSSKeyword_center, NS_STYLE_TEXT_ALIGN_CENTER },
+  { eCSSKeyword_justify, NS_STYLE_TEXT_ALIGN_JUSTIFY },
+  { eCSSKeyword_start, NS_STYLE_TEXT_ALIGN_START },
+  { eCSSKeyword_end, NS_STYLE_TEXT_ALIGN_END },
+  { eCSSKeyword_unsafe, NS_STYLE_TEXT_ALIGN_UNSAFE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTextCombineUprightKTable[] = {
+  { eCSSKeyword_none, NS_STYLE_TEXT_COMBINE_UPRIGHT_NONE },
+  { eCSSKeyword_all, NS_STYLE_TEXT_COMBINE_UPRIGHT_ALL },
+  { eCSSKeyword_digits, NS_STYLE_TEXT_COMBINE_UPRIGHT_DIGITS_2 }, // w/o number ==> 2
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTextDecorationLineKTable[] = {
+  { eCSSKeyword_none, NS_STYLE_TEXT_DECORATION_LINE_NONE },
+  { eCSSKeyword_underline, NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE },
+  { eCSSKeyword_overline, NS_STYLE_TEXT_DECORATION_LINE_OVERLINE },
+  { eCSSKeyword_line_through, NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH },
+  { eCSSKeyword_blink, NS_STYLE_TEXT_DECORATION_LINE_BLINK },
+  { eCSSKeyword__moz_anchor_decoration, NS_STYLE_TEXT_DECORATION_LINE_PREF_ANCHORS },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTextDecorationStyleKTable[] = {
+  { eCSSKeyword__moz_none, NS_STYLE_TEXT_DECORATION_STYLE_NONE },
+  { eCSSKeyword_solid, NS_STYLE_TEXT_DECORATION_STYLE_SOLID },
+  { eCSSKeyword_double, NS_STYLE_TEXT_DECORATION_STYLE_DOUBLE },
+  { eCSSKeyword_dotted, NS_STYLE_TEXT_DECORATION_STYLE_DOTTED },
+  { eCSSKeyword_dashed, NS_STYLE_TEXT_DECORATION_STYLE_DASHED },
+  { eCSSKeyword_wavy, NS_STYLE_TEXT_DECORATION_STYLE_WAVY },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTextOrientationKTable[] = {
+  { eCSSKeyword_mixed, NS_STYLE_TEXT_ORIENTATION_MIXED },
+  { eCSSKeyword_upright, NS_STYLE_TEXT_ORIENTATION_UPRIGHT },
+  { eCSSKeyword_sideways, NS_STYLE_TEXT_ORIENTATION_SIDEWAYS },
+  { eCSSKeyword_sideways_right, NS_STYLE_TEXT_ORIENTATION_SIDEWAYS },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTextEmphasisPositionKTable[] = {
+  { eCSSKeyword_over, NS_STYLE_TEXT_EMPHASIS_POSITION_OVER },
+  { eCSSKeyword_under, NS_STYLE_TEXT_EMPHASIS_POSITION_UNDER },
+  { eCSSKeyword_left, NS_STYLE_TEXT_EMPHASIS_POSITION_LEFT },
+  { eCSSKeyword_right, NS_STYLE_TEXT_EMPHASIS_POSITION_RIGHT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTextEmphasisStyleFillKTable[] = {
+  { eCSSKeyword_filled, NS_STYLE_TEXT_EMPHASIS_STYLE_FILLED },
+  { eCSSKeyword_open, NS_STYLE_TEXT_EMPHASIS_STYLE_OPEN },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTextEmphasisStyleShapeKTable[] = {
+  { eCSSKeyword_dot, NS_STYLE_TEXT_EMPHASIS_STYLE_DOT },
+  { eCSSKeyword_circle, NS_STYLE_TEXT_EMPHASIS_STYLE_CIRCLE },
+  { eCSSKeyword_double_circle, NS_STYLE_TEXT_EMPHASIS_STYLE_DOUBLE_CIRCLE },
+  { eCSSKeyword_triangle, NS_STYLE_TEXT_EMPHASIS_STYLE_TRIANGLE },
+  { eCSSKeyword_sesame, NS_STYLE_TEXT_EMPHASIS_STYLE_SESAME} ,
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTextOverflowKTable[] = {
+  { eCSSKeyword_clip, NS_STYLE_TEXT_OVERFLOW_CLIP },
+  { eCSSKeyword_ellipsis, NS_STYLE_TEXT_OVERFLOW_ELLIPSIS },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTextTransformKTable[] = {
+  { eCSSKeyword_none, NS_STYLE_TEXT_TRANSFORM_NONE },
+  { eCSSKeyword_capitalize, NS_STYLE_TEXT_TRANSFORM_CAPITALIZE },
+  { eCSSKeyword_lowercase, NS_STYLE_TEXT_TRANSFORM_LOWERCASE },
+  { eCSSKeyword_uppercase, NS_STYLE_TEXT_TRANSFORM_UPPERCASE },
+  { eCSSKeyword_full_width, NS_STYLE_TEXT_TRANSFORM_FULL_WIDTH },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTouchActionKTable[] = {
+  { eCSSKeyword_none,         NS_STYLE_TOUCH_ACTION_NONE },
+  { eCSSKeyword_auto,         NS_STYLE_TOUCH_ACTION_AUTO },
+  { eCSSKeyword_pan_x,        NS_STYLE_TOUCH_ACTION_PAN_X },
+  { eCSSKeyword_pan_y,        NS_STYLE_TOUCH_ACTION_PAN_Y },
+  { eCSSKeyword_manipulation, NS_STYLE_TOUCH_ACTION_MANIPULATION },
+  { eCSSKeyword_UNKNOWN,      -1 }
+};
+
+const KTableEntry nsCSSProps::kTopLayerKTable[] = {
+  { eCSSKeyword_none,     NS_STYLE_TOP_LAYER_NONE },
+  { eCSSKeyword_top,      NS_STYLE_TOP_LAYER_TOP },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTransformBoxKTable[] = {
+  { eCSSKeyword_border_box, NS_STYLE_TRANSFORM_BOX_BORDER_BOX },
+  { eCSSKeyword_fill_box, NS_STYLE_TRANSFORM_BOX_FILL_BOX },
+  { eCSSKeyword_view_box, NS_STYLE_TRANSFORM_BOX_VIEW_BOX },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTransitionTimingFunctionKTable[] = {
+  { eCSSKeyword_ease, NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE },
+  { eCSSKeyword_linear, NS_STYLE_TRANSITION_TIMING_FUNCTION_LINEAR },
+  { eCSSKeyword_ease_in, NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_IN },
+  { eCSSKeyword_ease_out, NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_OUT },
+  { eCSSKeyword_ease_in_out, NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_IN_OUT },
+  { eCSSKeyword_step_start, NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START },
+  { eCSSKeyword_step_end, NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_END },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kUnicodeBidiKTable[] = {
+  { eCSSKeyword_normal, NS_STYLE_UNICODE_BIDI_NORMAL },
+  { eCSSKeyword_embed, NS_STYLE_UNICODE_BIDI_EMBED },
+  { eCSSKeyword_bidi_override, NS_STYLE_UNICODE_BIDI_BIDI_OVERRIDE },
+  { eCSSKeyword_isolate, NS_STYLE_UNICODE_BIDI_ISOLATE },
+  { eCSSKeyword_isolate_override, NS_STYLE_UNICODE_BIDI_ISOLATE_OVERRIDE },
+  { eCSSKeyword_plaintext, NS_STYLE_UNICODE_BIDI_PLAINTEXT },
+  { eCSSKeyword__moz_isolate, NS_STYLE_UNICODE_BIDI_ISOLATE },
+  { eCSSKeyword__moz_isolate_override, NS_STYLE_UNICODE_BIDI_ISOLATE_OVERRIDE },
+  { eCSSKeyword__moz_plaintext, NS_STYLE_UNICODE_BIDI_PLAINTEXT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kUserFocusKTable[] = {
+  { eCSSKeyword_none,           uint8_t(StyleUserFocus::None) },
+  { eCSSKeyword_normal,         uint8_t(StyleUserFocus::Normal) },
+  { eCSSKeyword_ignore,         uint8_t(StyleUserFocus::Ignore) },
+  { eCSSKeyword_select_all,     uint8_t(StyleUserFocus::SelectAll) },
+  { eCSSKeyword_select_before,  uint8_t(StyleUserFocus::SelectBefore) },
+  { eCSSKeyword_select_after,   uint8_t(StyleUserFocus::SelectAfter) },
+  { eCSSKeyword_select_same,    uint8_t(StyleUserFocus::SelectSame) },
+  { eCSSKeyword_select_menu,    uint8_t(StyleUserFocus::SelectMenu) },
+  { eCSSKeyword_UNKNOWN,        -1 }
+};
+
+const KTableEntry nsCSSProps::kUserInputKTable[] = {
+  { eCSSKeyword_none,     StyleUserInput::None },
+  { eCSSKeyword_enabled,  StyleUserInput::Enabled },
+  { eCSSKeyword_disabled, StyleUserInput::Disabled },
+  { eCSSKeyword_auto,     StyleUserInput::Auto },
+  { eCSSKeyword_UNKNOWN,  -1 }
+};
+
+const KTableEntry nsCSSProps::kUserModifyKTable[] = {
+  { eCSSKeyword_read_only,  StyleUserModify::ReadOnly },
+  { eCSSKeyword_read_write, StyleUserModify::ReadWrite },
+  { eCSSKeyword_write_only, StyleUserModify::WriteOnly },
+  { eCSSKeyword_UNKNOWN,    -1 }
+};
+
+const KTableEntry nsCSSProps::kUserSelectKTable[] = {
+  { eCSSKeyword_none,       StyleUserSelect::None },
+  { eCSSKeyword_auto,       StyleUserSelect::Auto },
+  { eCSSKeyword_text,       StyleUserSelect::Text },
+  { eCSSKeyword_element,    StyleUserSelect::Element },
+  { eCSSKeyword_elements,   StyleUserSelect::Elements },
+  { eCSSKeyword_all,        StyleUserSelect::All },
+  { eCSSKeyword_toggle,     StyleUserSelect::Toggle },
+  { eCSSKeyword_tri_state,  StyleUserSelect::TriState },
+  { eCSSKeyword__moz_all,   StyleUserSelect::MozAll },
+  { eCSSKeyword__moz_none,  StyleUserSelect::None },
+  { eCSSKeyword__moz_text,  StyleUserSelect::MozText },
+  { eCSSKeyword_UNKNOWN,    -1 }
+};
+
+const KTableEntry nsCSSProps::kVerticalAlignKTable[] = {
+  { eCSSKeyword_baseline, NS_STYLE_VERTICAL_ALIGN_BASELINE },
+  { eCSSKeyword_sub, NS_STYLE_VERTICAL_ALIGN_SUB },
+  { eCSSKeyword_super, NS_STYLE_VERTICAL_ALIGN_SUPER },
+  { eCSSKeyword_top, NS_STYLE_VERTICAL_ALIGN_TOP },
+  { eCSSKeyword_text_top, NS_STYLE_VERTICAL_ALIGN_TEXT_TOP },
+  { eCSSKeyword_middle, NS_STYLE_VERTICAL_ALIGN_MIDDLE },
+  { eCSSKeyword__moz_middle_with_baseline, NS_STYLE_VERTICAL_ALIGN_MIDDLE_WITH_BASELINE },
+  { eCSSKeyword_bottom, NS_STYLE_VERTICAL_ALIGN_BOTTOM },
+  { eCSSKeyword_text_bottom, NS_STYLE_VERTICAL_ALIGN_TEXT_BOTTOM },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kVisibilityKTable[] = {
+  { eCSSKeyword_visible, NS_STYLE_VISIBILITY_VISIBLE },
+  { eCSSKeyword_hidden, NS_STYLE_VISIBILITY_HIDDEN },
+  { eCSSKeyword_collapse, NS_STYLE_VISIBILITY_COLLAPSE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kWhitespaceKTable[] = {
+  { eCSSKeyword_normal, NS_STYLE_WHITESPACE_NORMAL },
+  { eCSSKeyword_pre, NS_STYLE_WHITESPACE_PRE },
+  { eCSSKeyword_nowrap, NS_STYLE_WHITESPACE_NOWRAP },
+  { eCSSKeyword_pre_wrap, NS_STYLE_WHITESPACE_PRE_WRAP },
+  { eCSSKeyword_pre_line, NS_STYLE_WHITESPACE_PRE_LINE },
+  { eCSSKeyword__moz_pre_space, NS_STYLE_WHITESPACE_PRE_SPACE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kWidthKTable[] = {
+  { eCSSKeyword__moz_max_content, NS_STYLE_WIDTH_MAX_CONTENT },
+  { eCSSKeyword__moz_min_content, NS_STYLE_WIDTH_MIN_CONTENT },
+  { eCSSKeyword__moz_fit_content, NS_STYLE_WIDTH_FIT_CONTENT },
+  { eCSSKeyword__moz_available, NS_STYLE_WIDTH_AVAILABLE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kWindowDraggingKTable[] = {
+  { eCSSKeyword_default, StyleWindowDragging::Default },
+  { eCSSKeyword_drag, StyleWindowDragging::Drag },
+  { eCSSKeyword_no_drag, StyleWindowDragging::NoDrag },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kWindowShadowKTable[] = {
+  { eCSSKeyword_none, NS_STYLE_WINDOW_SHADOW_NONE },
+  { eCSSKeyword_default, NS_STYLE_WINDOW_SHADOW_DEFAULT },
+  { eCSSKeyword_menu, NS_STYLE_WINDOW_SHADOW_MENU },
+  { eCSSKeyword_tooltip, NS_STYLE_WINDOW_SHADOW_TOOLTIP },
+  { eCSSKeyword_sheet, NS_STYLE_WINDOW_SHADOW_SHEET },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kWordBreakKTable[] = {
+  { eCSSKeyword_normal, NS_STYLE_WORDBREAK_NORMAL },
+  { eCSSKeyword_break_all, NS_STYLE_WORDBREAK_BREAK_ALL },
+  { eCSSKeyword_keep_all, NS_STYLE_WORDBREAK_KEEP_ALL },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kOverflowWrapKTable[] = {
+  { eCSSKeyword_normal, NS_STYLE_OVERFLOWWRAP_NORMAL },
+  { eCSSKeyword_break_word, NS_STYLE_OVERFLOWWRAP_BREAK_WORD },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kWritingModeKTable[] = {
+  { eCSSKeyword_horizontal_tb, NS_STYLE_WRITING_MODE_HORIZONTAL_TB },
+  { eCSSKeyword_vertical_lr, NS_STYLE_WRITING_MODE_VERTICAL_LR },
+  { eCSSKeyword_vertical_rl, NS_STYLE_WRITING_MODE_VERTICAL_RL },
+  { eCSSKeyword_sideways_lr, NS_STYLE_WRITING_MODE_SIDEWAYS_LR },
+  { eCSSKeyword_sideways_rl, NS_STYLE_WRITING_MODE_SIDEWAYS_RL },
+  { eCSSKeyword_lr, NS_STYLE_WRITING_MODE_HORIZONTAL_TB },
+  { eCSSKeyword_lr_tb, NS_STYLE_WRITING_MODE_HORIZONTAL_TB },
+  { eCSSKeyword_rl, NS_STYLE_WRITING_MODE_HORIZONTAL_TB },
+  { eCSSKeyword_rl_tb, NS_STYLE_WRITING_MODE_HORIZONTAL_TB },
+  { eCSSKeyword_tb, NS_STYLE_WRITING_MODE_VERTICAL_RL },
+  { eCSSKeyword_tb_rl, NS_STYLE_WRITING_MODE_VERTICAL_RL },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+// Specific keyword tables for XUL.properties
+const KTableEntry nsCSSProps::kBoxAlignKTable[] = {
+  { eCSSKeyword_stretch, StyleBoxAlign::Stretch },
+  { eCSSKeyword_start, StyleBoxAlign::Start },
+  { eCSSKeyword_center, StyleBoxAlign::Center },
+  { eCSSKeyword_baseline, StyleBoxAlign::Baseline },
+  { eCSSKeyword_end, StyleBoxAlign::End },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kBoxDirectionKTable[] = {
+  { eCSSKeyword_normal, StyleBoxDirection::Normal },
+  { eCSSKeyword_reverse, StyleBoxDirection::Reverse },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kBoxOrientKTable[] = {
+  { eCSSKeyword_horizontal, StyleBoxOrient::Horizontal },
+  { eCSSKeyword_vertical, StyleBoxOrient::Vertical },
+  { eCSSKeyword_inline_axis, StyleBoxOrient::Horizontal },
+  { eCSSKeyword_block_axis, StyleBoxOrient::Vertical },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kBoxPackKTable[] = {
+  { eCSSKeyword_start, StyleBoxPack::Start },
+  { eCSSKeyword_center, StyleBoxPack::Center },
+  { eCSSKeyword_end, StyleBoxPack::End },
+  { eCSSKeyword_justify, StyleBoxPack::Justify },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+// keyword tables for SVG properties
+
+const KTableEntry nsCSSProps::kDominantBaselineKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_DOMINANT_BASELINE_AUTO },
+  { eCSSKeyword_use_script, NS_STYLE_DOMINANT_BASELINE_USE_SCRIPT },
+  { eCSSKeyword_no_change, NS_STYLE_DOMINANT_BASELINE_NO_CHANGE },
+  { eCSSKeyword_reset_size, NS_STYLE_DOMINANT_BASELINE_RESET_SIZE },
+  { eCSSKeyword_alphabetic, NS_STYLE_DOMINANT_BASELINE_ALPHABETIC },
+  { eCSSKeyword_hanging, NS_STYLE_DOMINANT_BASELINE_HANGING },
+  { eCSSKeyword_ideographic, NS_STYLE_DOMINANT_BASELINE_IDEOGRAPHIC },
+  { eCSSKeyword_mathematical, NS_STYLE_DOMINANT_BASELINE_MATHEMATICAL },
+  { eCSSKeyword_central, NS_STYLE_DOMINANT_BASELINE_CENTRAL },
+  { eCSSKeyword_middle, NS_STYLE_DOMINANT_BASELINE_MIDDLE },
+  { eCSSKeyword_text_after_edge, NS_STYLE_DOMINANT_BASELINE_TEXT_AFTER_EDGE },
+  { eCSSKeyword_text_before_edge, NS_STYLE_DOMINANT_BASELINE_TEXT_BEFORE_EDGE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFillRuleKTable[] = {
+  { eCSSKeyword_nonzero, StyleFillRule::Nonzero },
+  { eCSSKeyword_evenodd, StyleFillRule::Evenodd },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kClipPathGeometryBoxKTable[] = {
+  { eCSSKeyword_content_box, StyleClipPathGeometryBox::Content },
+  { eCSSKeyword_padding_box, StyleClipPathGeometryBox::Padding },
+  { eCSSKeyword_border_box, StyleClipPathGeometryBox::Border },
+  { eCSSKeyword_margin_box, StyleClipPathGeometryBox::Margin },
+  { eCSSKeyword_fill_box, StyleClipPathGeometryBox::Fill },
+  { eCSSKeyword_stroke_box, StyleClipPathGeometryBox::Stroke },
+  { eCSSKeyword_view_box, StyleClipPathGeometryBox::View },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kShapeRadiusKTable[] = {
+  { eCSSKeyword_closest_side, NS_RADIUS_CLOSEST_SIDE },
+  { eCSSKeyword_farthest_side, NS_RADIUS_FARTHEST_SIDE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kFilterFunctionKTable[] = {
+  { eCSSKeyword_blur, NS_STYLE_FILTER_BLUR },
+  { eCSSKeyword_brightness, NS_STYLE_FILTER_BRIGHTNESS },
+  { eCSSKeyword_contrast, NS_STYLE_FILTER_CONTRAST },
+  { eCSSKeyword_grayscale, NS_STYLE_FILTER_GRAYSCALE },
+  { eCSSKeyword_invert, NS_STYLE_FILTER_INVERT },
+  { eCSSKeyword_opacity, NS_STYLE_FILTER_OPACITY },
+  { eCSSKeyword_saturate, NS_STYLE_FILTER_SATURATE },
+  { eCSSKeyword_sepia, NS_STYLE_FILTER_SEPIA },
+  { eCSSKeyword_hue_rotate, NS_STYLE_FILTER_HUE_ROTATE },
+  { eCSSKeyword_drop_shadow, NS_STYLE_FILTER_DROP_SHADOW },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kImageRenderingKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_IMAGE_RENDERING_AUTO },
+  { eCSSKeyword_optimizespeed, NS_STYLE_IMAGE_RENDERING_OPTIMIZESPEED },
+  { eCSSKeyword_optimizequality, NS_STYLE_IMAGE_RENDERING_OPTIMIZEQUALITY },
+  { eCSSKeyword__moz_crisp_edges, NS_STYLE_IMAGE_RENDERING_CRISPEDGES },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kMaskTypeKTable[] = {
+  { eCSSKeyword_luminance, NS_STYLE_MASK_TYPE_LUMINANCE },
+  { eCSSKeyword_alpha, NS_STYLE_MASK_TYPE_ALPHA },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kShapeOutsideShapeBoxKTable[] = {
+  { eCSSKeyword_content_box, StyleShapeOutsideShapeBox::Content },
+  { eCSSKeyword_padding_box, StyleShapeOutsideShapeBox::Padding },
+  { eCSSKeyword_border_box, StyleShapeOutsideShapeBox::Border },
+  { eCSSKeyword_margin_box, StyleShapeOutsideShapeBox::Margin },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kShapeRenderingKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_SHAPE_RENDERING_AUTO },
+  { eCSSKeyword_optimizespeed, NS_STYLE_SHAPE_RENDERING_OPTIMIZESPEED },
+  { eCSSKeyword_crispedges, NS_STYLE_SHAPE_RENDERING_CRISPEDGES },
+  { eCSSKeyword_geometricprecision, NS_STYLE_SHAPE_RENDERING_GEOMETRICPRECISION },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kStrokeLinecapKTable[] = {
+  { eCSSKeyword_butt, NS_STYLE_STROKE_LINECAP_BUTT },
+  { eCSSKeyword_round, NS_STYLE_STROKE_LINECAP_ROUND },
+  { eCSSKeyword_square, NS_STYLE_STROKE_LINECAP_SQUARE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kStrokeLinejoinKTable[] = {
+  { eCSSKeyword_miter, NS_STYLE_STROKE_LINEJOIN_MITER },
+  { eCSSKeyword_round, NS_STYLE_STROKE_LINEJOIN_ROUND },
+  { eCSSKeyword_bevel, NS_STYLE_STROKE_LINEJOIN_BEVEL },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+// Lookup table to store the sole objectValue keyword to let SVG glyphs inherit
+// certain stroke-* properties from the outer text object
+const KTableEntry nsCSSProps::kStrokeContextValueKTable[] = {
+  { eCSSKeyword_context_value, NS_STYLE_STROKE_PROP_CONTEXT_VALUE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTextAnchorKTable[] = {
+  { eCSSKeyword_start, NS_STYLE_TEXT_ANCHOR_START },
+  { eCSSKeyword_middle, NS_STYLE_TEXT_ANCHOR_MIDDLE },
+  { eCSSKeyword_end, NS_STYLE_TEXT_ANCHOR_END },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kTextRenderingKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_TEXT_RENDERING_AUTO },
+  { eCSSKeyword_optimizespeed, NS_STYLE_TEXT_RENDERING_OPTIMIZESPEED },
+  { eCSSKeyword_optimizelegibility, NS_STYLE_TEXT_RENDERING_OPTIMIZELEGIBILITY },
+  { eCSSKeyword_geometricprecision, NS_STYLE_TEXT_RENDERING_GEOMETRICPRECISION },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kVectorEffectKTable[] = {
+  { eCSSKeyword_none, NS_STYLE_VECTOR_EFFECT_NONE },
+  { eCSSKeyword_non_scaling_stroke, NS_STYLE_VECTOR_EFFECT_NON_SCALING_STROKE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kColorAdjustKTable[] = {
+  { eCSSKeyword_economy, NS_STYLE_COLOR_ADJUST_ECONOMY },
+  { eCSSKeyword_exact, NS_STYLE_COLOR_ADJUST_EXACT },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kColorInterpolationKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_COLOR_INTERPOLATION_AUTO },
+  { eCSSKeyword_srgb, NS_STYLE_COLOR_INTERPOLATION_SRGB },
+  { eCSSKeyword_linearrgb, NS_STYLE_COLOR_INTERPOLATION_LINEARRGB },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+const KTableEntry nsCSSProps::kColumnFillKTable[] = {
+  { eCSSKeyword_auto, NS_STYLE_COLUMN_FILL_AUTO },
+  { eCSSKeyword_balance, NS_STYLE_COLUMN_FILL_BALANCE },
+  { eCSSKeyword_UNKNOWN, -1 }
+};
+
+static inline bool
+IsKeyValSentinel(const KTableEntry& aTableEntry)
+{
+  return aTableEntry.mKeyword == eCSSKeyword_UNKNOWN &&
+         aTableEntry.mValue == -1;
+}
+
+int32_t
+nsCSSProps::FindIndexOfKeyword(nsCSSKeyword aKeyword,
+                               const KTableEntry aTable[])
+{
+  if (eCSSKeyword_UNKNOWN == aKeyword) {
+    // NOTE: we can have keyword tables where eCSSKeyword_UNKNOWN is used
+    // not only for the sentinel, but also in the middle of the table to
+    // knock out values that have been disabled by prefs, e.g. kDisplayKTable.
+    // So we deal with eCSSKeyword_UNKNOWN up front to avoid returning a valid
+    // index in the loop below.
+    return -1;
+  }
+  for (int32_t i = 0; ; ++i) {
+    const KTableEntry& entry = aTable[i];
+    if (::IsKeyValSentinel(entry)) {
+      break;
+    }
+    if (aKeyword == entry.mKeyword) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+bool
+nsCSSProps::FindKeyword(nsCSSKeyword aKeyword, const KTableEntry aTable[],
+                        int32_t& aResult)
+{
+  int32_t index = FindIndexOfKeyword(aKeyword, aTable);
+  if (index >= 0) {
+    aResult = aTable[index].mValue;
+    return true;
+  }
+  return false;
+}
+
+nsCSSKeyword
+nsCSSProps::ValueToKeywordEnum(int32_t aValue, const KTableEntry aTable[])
+{
+#ifdef DEBUG
+  typedef decltype(aTable[0].mValue) table_value_type;
+  NS_ASSERTION(table_value_type(aValue) == aValue, "Value out of range");
+#endif
+  for (int32_t i = 0; ; ++i) {
+    const KTableEntry& entry = aTable[i];
+    if (::IsKeyValSentinel(entry)) {
+      break;
+    }
+    if (aValue == entry.mValue) {
+      return entry.mKeyword;
+    }
+  }
+  return eCSSKeyword_UNKNOWN;
+}
+
+const nsAFlatCString&
+nsCSSProps::ValueToKeyword(int32_t aValue, const KTableEntry aTable[])
+{
+  nsCSSKeyword keyword = ValueToKeywordEnum(aValue, aTable);
+  if (keyword == eCSSKeyword_UNKNOWN) {
+    static nsDependentCString sNullStr("");
+    return sNullStr;
+  } else {
+    return nsCSSKeywords::GetStringValue(keyword);
+  }
+}
+
+/* static */ const KTableEntry* const
+nsCSSProps::kKeywordTableTable[eCSSProperty_COUNT_no_shorthands] = {
+  #define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_,     \
+                   kwtable_, stylestruct_, stylestructoffset_, animtype_) \
+    kwtable_,
+  #define CSS_PROP_LIST_INCLUDE_LOGICAL
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_LIST_INCLUDE_LOGICAL
+  #undef CSS_PROP
+};
+
+const nsAFlatCString&
+nsCSSProps::LookupPropertyValue(nsCSSPropertyID aProp, int32_t aValue)
+{
+  MOZ_ASSERT(aProp >= 0 && aProp < eCSSProperty_COUNT,
+             "property out of range");
+#ifdef DEBUG
+  typedef decltype(KTableEntry::mValue) table_value_type;
+  NS_ASSERTION(table_value_type(aValue) == aValue, "Value out of range");
+#endif
+
+  const KTableEntry* kwtable = nullptr;
+  if (aProp < eCSSProperty_COUNT_no_shorthands)
+    kwtable = kKeywordTableTable[aProp];
+
+  if (kwtable)
+    return ValueToKeyword(aValue, kwtable);
+
+  static nsDependentCString sNullStr("");
+  return sNullStr;
+}
+
+bool nsCSSProps::GetColorName(int32_t aPropValue, nsCString &aStr)
+{
+  bool rv = false;
+
+  // first get the keyword corresponding to the property Value from the color table
+  nsCSSKeyword keyword = ValueToKeywordEnum(aPropValue, kColorKTable);
+
+  // next get the name as a string from the keywords table
+  if (keyword != eCSSKeyword_UNKNOWN) {
+    nsCSSKeywords::AddRefTable();
+    aStr = nsCSSKeywords::GetStringValue(keyword);
+    nsCSSKeywords::ReleaseTable();
+    rv = true;
+  }
+  return rv;
+}
+
+const nsStyleStructID nsCSSProps::kSIDTable[eCSSProperty_COUNT_no_shorthands] = {
+    #define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_,     \
+                     kwtable_, stylestruct_, stylestructoffset_, animtype_) \
+        eStyleStruct_##stylestruct_,
+    #define CSS_PROP_LIST_INCLUDE_LOGICAL
+
+    #include "nsCSSPropList.h"
+
+    #undef CSS_PROP_LIST_INCLUDE_LOGICAL
+    #undef CSS_PROP
+};
+
+const nsStyleAnimType
+nsCSSProps::kAnimTypeTable[eCSSProperty_COUNT_no_shorthands] = {
+#define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_, kwtable_, \
+                 stylestruct_, stylestructoffset_, animtype_)                 \
+  animtype_,
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP
+};
+
+const ptrdiff_t
+nsCSSProps::kStyleStructOffsetTable[eCSSProperty_COUNT_no_shorthands] = {
+#define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_, kwtable_, \
+                 stylestruct_, stylestructoffset_, animtype_)                 \
+  stylestructoffset_,
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP
+};
+
+const uint32_t nsCSSProps::kFlagsTable[eCSSProperty_COUNT] = {
+#define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_, kwtable_, \
+                 stylestruct_, stylestructoffset_, animtype_)                 \
+  flags_,
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP
+#define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) flags_,
+#include "nsCSSPropList.h"
+#undef CSS_PROP_SHORTHAND
+};
+
+static const nsCSSPropertyID gAllSubpropTable[] = {
+#define CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_, kwtable_, \
+                 stylestruct_, stylestructoffset_, animtype_)                 \
+  eCSSProperty_##id_,
+#include "nsCSSPropList.h"
+#undef CSS_PROP
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gAnimationSubpropTable[] = {
+  eCSSProperty_animation_duration,
+  eCSSProperty_animation_timing_function,
+  eCSSProperty_animation_delay,
+  eCSSProperty_animation_direction,
+  eCSSProperty_animation_fill_mode,
+  eCSSProperty_animation_iteration_count,
+  eCSSProperty_animation_play_state,
+  // List animation-name last so we serialize it last, in case it has
+  // a value that conflicts with one of the other properties.  (See
+  // how Declaration::GetValue serializes 'animation'.
+  eCSSProperty_animation_name,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderRadiusSubpropTable[] = {
+  // Code relies on these being in topleft-topright-bottomright-bottomleft
+  // order.
+  eCSSProperty_border_top_left_radius,
+  eCSSProperty_border_top_right_radius,
+  eCSSProperty_border_bottom_right_radius,
+  eCSSProperty_border_bottom_left_radius,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gOutlineRadiusSubpropTable[] = {
+  // Code relies on these being in topleft-topright-bottomright-bottomleft
+  // order.
+  eCSSProperty__moz_outline_radius_topLeft,
+  eCSSProperty__moz_outline_radius_topRight,
+  eCSSProperty__moz_outline_radius_bottomRight,
+  eCSSProperty__moz_outline_radius_bottomLeft,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBackgroundSubpropTable[] = {
+  eCSSProperty_background_color,
+  eCSSProperty_background_image,
+  eCSSProperty_background_repeat,
+  eCSSProperty_background_attachment,
+  eCSSProperty_background_clip,
+  eCSSProperty_background_origin,
+  eCSSProperty_background_position_x,
+  eCSSProperty_background_position_y,
+  eCSSProperty_background_size,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBackgroundPositionSubpropTable[] = {
+  eCSSProperty_background_position_x,
+  eCSSProperty_background_position_y,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderSubpropTable[] = {
+  eCSSProperty_border_top_width,
+  eCSSProperty_border_right_width,
+  eCSSProperty_border_bottom_width,
+  eCSSProperty_border_left_width,
+  eCSSProperty_border_top_style,
+  eCSSProperty_border_right_style,
+  eCSSProperty_border_bottom_style,
+  eCSSProperty_border_left_style,
+  eCSSProperty_border_top_color,
+  eCSSProperty_border_right_color,
+  eCSSProperty_border_bottom_color,
+  eCSSProperty_border_left_color,
+  eCSSProperty_border_top_colors,
+  eCSSProperty_border_right_colors,
+  eCSSProperty_border_bottom_colors,
+  eCSSProperty_border_left_colors,
+  eCSSProperty_border_image_source,
+  eCSSProperty_border_image_slice,
+  eCSSProperty_border_image_width,
+  eCSSProperty_border_image_outset,
+  eCSSProperty_border_image_repeat,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderBlockEndSubpropTable[] = {
+  // Declaration.cpp outputs the subproperties in this order.
+  // It also depends on the color being third.
+  eCSSProperty_border_block_end_width,
+  eCSSProperty_border_block_end_style,
+  eCSSProperty_border_block_end_color,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderBlockStartSubpropTable[] = {
+  // Declaration.cpp outputs the subproperties in this order.
+  // It also depends on the color being third.
+  eCSSProperty_border_block_start_width,
+  eCSSProperty_border_block_start_style,
+  eCSSProperty_border_block_start_color,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderBottomSubpropTable[] = {
+  // Declaration.cpp outputs the subproperties in this order.
+  // It also depends on the color being third.
+  eCSSProperty_border_bottom_width,
+  eCSSProperty_border_bottom_style,
+  eCSSProperty_border_bottom_color,
+  eCSSProperty_UNKNOWN
+};
+
+static_assert(NS_SIDE_TOP == 0 && NS_SIDE_RIGHT == 1 &&
+              NS_SIDE_BOTTOM == 2 && NS_SIDE_LEFT == 3,
+              "box side constants not top/right/bottom/left == 0/1/2/3");
+static const nsCSSPropertyID gBorderColorSubpropTable[] = {
+  // Code relies on these being in top-right-bottom-left order.
+  // Code relies on these matching the NS_SIDE_* constants.
+  eCSSProperty_border_top_color,
+  eCSSProperty_border_right_color,
+  eCSSProperty_border_bottom_color,
+  eCSSProperty_border_left_color,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderInlineEndSubpropTable[] = {
+  // Declaration.cpp output the subproperties in this order.
+  // It also depends on the color being third.
+  eCSSProperty_border_inline_end_width,
+  eCSSProperty_border_inline_end_style,
+  eCSSProperty_border_inline_end_color,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderLeftSubpropTable[] = {
+  // Declaration.cpp outputs the subproperties in this order.
+  // It also depends on the color being third.
+  eCSSProperty_border_left_width,
+  eCSSProperty_border_left_style,
+  eCSSProperty_border_left_color,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderRightSubpropTable[] = {
+  // Declaration.cpp outputs the subproperties in this order.
+  // It also depends on the color being third.
+  eCSSProperty_border_right_width,
+  eCSSProperty_border_right_style,
+  eCSSProperty_border_right_color,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderInlineStartSubpropTable[] = {
+  // Declaration.cpp outputs the subproperties in this order.
+  // It also depends on the color being third.
+  eCSSProperty_border_inline_start_width,
+  eCSSProperty_border_inline_start_style,
+  eCSSProperty_border_inline_start_color,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderStyleSubpropTable[] = {
+  // Code relies on these being in top-right-bottom-left order.
+  eCSSProperty_border_top_style,
+  eCSSProperty_border_right_style,
+  eCSSProperty_border_bottom_style,
+  eCSSProperty_border_left_style,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderTopSubpropTable[] = {
+  // Declaration.cpp outputs the subproperties in this order.
+  // It also depends on the color being third.
+  eCSSProperty_border_top_width,
+  eCSSProperty_border_top_style,
+  eCSSProperty_border_top_color,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderWidthSubpropTable[] = {
+  // Code relies on these being in top-right-bottom-left order.
+  eCSSProperty_border_top_width,
+  eCSSProperty_border_right_width,
+  eCSSProperty_border_bottom_width,
+  eCSSProperty_border_left_width,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gFontSubpropTable[] = {
+  eCSSProperty_font_family,
+  eCSSProperty_font_style,
+  eCSSProperty_font_weight,
+  eCSSProperty_font_size,
+  eCSSProperty_line_height,
+  eCSSProperty_font_size_adjust,
+  eCSSProperty_font_stretch,
+  eCSSProperty__x_system_font,
+  eCSSProperty_font_feature_settings,
+  eCSSProperty_font_language_override,
+  eCSSProperty_font_kerning,
+  eCSSProperty_font_synthesis,
+  eCSSProperty_font_variant_alternates,
+  eCSSProperty_font_variant_caps,
+  eCSSProperty_font_variant_east_asian,
+  eCSSProperty_font_variant_ligatures,
+  eCSSProperty_font_variant_numeric,
+  eCSSProperty_font_variant_position,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gFontVariantSubpropTable[] = {
+  eCSSProperty_font_variant_alternates,
+  eCSSProperty_font_variant_caps,
+  eCSSProperty_font_variant_east_asian,
+  eCSSProperty_font_variant_ligatures,
+  eCSSProperty_font_variant_numeric,
+  eCSSProperty_font_variant_position,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gListStyleSubpropTable[] = {
+  eCSSProperty_list_style_type,
+  eCSSProperty_list_style_image,
+  eCSSProperty_list_style_position,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gMarginSubpropTable[] = {
+  // Code relies on these being in top-right-bottom-left order.
+  eCSSProperty_margin_top,
+  eCSSProperty_margin_right,
+  eCSSProperty_margin_bottom,
+  eCSSProperty_margin_left,
+  eCSSProperty_UNKNOWN
+};
+
+
+static const nsCSSPropertyID gOutlineSubpropTable[] = {
+  // nsCSSDeclaration.cpp outputs the subproperties in this order.
+  // It also depends on the color being third.
+  eCSSProperty_outline_width,
+  eCSSProperty_outline_style,
+  eCSSProperty_outline_color,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gColumnsSubpropTable[] = {
+  eCSSProperty_column_count,
+  eCSSProperty_column_width,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gColumnRuleSubpropTable[] = {
+  // nsCSSDeclaration.cpp outputs the subproperties in this order.
+  // It also depends on the color being third.
+  eCSSProperty_column_rule_width,
+  eCSSProperty_column_rule_style,
+  eCSSProperty_column_rule_color,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gFlexSubpropTable[] = {
+  eCSSProperty_flex_grow,
+  eCSSProperty_flex_shrink,
+  eCSSProperty_flex_basis,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gFlexFlowSubpropTable[] = {
+  eCSSProperty_flex_direction,
+  eCSSProperty_flex_wrap,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gGridTemplateSubpropTable[] = {
+  eCSSProperty_grid_template_areas,
+  eCSSProperty_grid_template_rows, 
+  eCSSProperty_grid_template_columns,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gGridSubpropTable[] = {
+  eCSSProperty_grid_template_areas,
+  eCSSProperty_grid_template_rows,
+  eCSSProperty_grid_template_columns,
+  eCSSProperty_grid_auto_flow,
+  eCSSProperty_grid_auto_rows,
+  eCSSProperty_grid_auto_columns,
+  eCSSProperty_grid_row_gap, // can only be reset, not get/set
+  eCSSProperty_grid_column_gap, // can only be reset, not get/set
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gGridColumnSubpropTable[] = {
+  eCSSProperty_grid_column_start,
+  eCSSProperty_grid_column_end,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gGridRowSubpropTable[] = {
+  eCSSProperty_grid_row_start,
+  eCSSProperty_grid_row_end,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gGridAreaSubpropTable[] = {
+  eCSSProperty_grid_row_start,
+  eCSSProperty_grid_column_start,
+  eCSSProperty_grid_row_end,
+  eCSSProperty_grid_column_end,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gGridGapSubpropTable[] = {
+  eCSSProperty_grid_row_gap,
+  eCSSProperty_grid_column_gap,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gOverflowSubpropTable[] = {
+  eCSSProperty_overflow_x,
+  eCSSProperty_overflow_y,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gPaddingSubpropTable[] = {
+  // Code relies on these being in top-right-bottom-left order.
+  eCSSProperty_padding_top,
+  eCSSProperty_padding_right,
+  eCSSProperty_padding_bottom,
+  eCSSProperty_padding_left,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gTextDecorationSubpropTable[] = {
+  eCSSProperty_text_decoration_color,
+  eCSSProperty_text_decoration_line,
+  eCSSProperty_text_decoration_style,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gTextEmphasisSubpropTable[] = {
+  eCSSProperty_text_emphasis_style,
+  eCSSProperty_text_emphasis_color,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gWebkitTextStrokeSubpropTable[] = {
+  eCSSProperty__webkit_text_stroke_width,
+  eCSSProperty__webkit_text_stroke_color,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gTransitionSubpropTable[] = {
+  eCSSProperty_transition_property,
+  eCSSProperty_transition_duration,
+  eCSSProperty_transition_timing_function,
+  eCSSProperty_transition_delay,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gBorderImageSubpropTable[] = {
+  eCSSProperty_border_image_source,
+  eCSSProperty_border_image_slice,
+  eCSSProperty_border_image_width,
+  eCSSProperty_border_image_outset,
+  eCSSProperty_border_image_repeat,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gMarkerSubpropTable[] = {
+  eCSSProperty_marker_start,
+  eCSSProperty_marker_mid,
+  eCSSProperty_marker_end,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gPlaceContentSubpropTable[] = {
+  eCSSProperty_align_content,
+  eCSSProperty_justify_content,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gPlaceItemsSubpropTable[] = {
+  eCSSProperty_align_items,
+  eCSSProperty_justify_items,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gPlaceSelfSubpropTable[] = {
+  eCSSProperty_align_self,
+  eCSSProperty_justify_self,
+  eCSSProperty_UNKNOWN
+};
+
+// Subproperty tables for shorthands that are just aliases with
+// different parsing rules.
+static const nsCSSPropertyID gMozTransformSubpropTable[] = {
+  eCSSProperty_transform,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gScrollSnapTypeSubpropTable[] = {
+  eCSSProperty_scroll_snap_type_x,
+  eCSSProperty_scroll_snap_type_y,
+  eCSSProperty_UNKNOWN
+};
+#ifdef MOZ_ENABLE_MASK_AS_SHORTHAND
+static const nsCSSPropertyID gMaskSubpropTable[] = {
+  eCSSProperty_mask_image,
+  eCSSProperty_mask_repeat,
+  eCSSProperty_mask_position_x,
+  eCSSProperty_mask_position_y,
+  eCSSProperty_mask_clip,
+  eCSSProperty_mask_origin,
+  eCSSProperty_mask_size,
+  eCSSProperty_mask_composite,
+  eCSSProperty_mask_mode,
+  eCSSProperty_UNKNOWN
+};
+static const nsCSSPropertyID gMaskPositionSubpropTable[] = {
+  eCSSProperty_mask_position_x,
+  eCSSProperty_mask_position_y,
+  eCSSProperty_UNKNOWN
+};
+#endif
+// FIXME: mask-border tables should be added when we implement
+// mask-border properties.
+
+const nsCSSPropertyID *const
+nsCSSProps::kSubpropertyTable[eCSSProperty_COUNT - eCSSProperty_COUNT_no_shorthands] = {
+#define CSS_PROP_PUBLIC_OR_PRIVATE(publicname_, privatename_) privatename_
+// Need an extra level of macro nesting to force expansion of method_
+// params before they get pasted.
+#define NSCSSPROPS_INNER_MACRO(method_) g##method_##SubpropTable,
+#define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) \
+  NSCSSPROPS_INNER_MACRO(method_)
+#include "nsCSSPropList.h"
+#undef CSS_PROP_SHORTHAND
+#undef NSCSSPROPS_INNER_MACRO
+#undef CSS_PROP_PUBLIC_OR_PRIVATE
+};
+
+
+static const nsCSSPropertyID gOffsetLogicalGroupTable[] = {
+  eCSSProperty_top,
+  eCSSProperty_right,
+  eCSSProperty_bottom,
+  eCSSProperty_left,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gMaxSizeLogicalGroupTable[] = {
+  eCSSProperty_max_height,
+  eCSSProperty_max_width,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gMinSizeLogicalGroupTable[] = {
+  eCSSProperty_min_height,
+  eCSSProperty_min_width,
+  eCSSProperty_UNKNOWN
+};
+
+static const nsCSSPropertyID gSizeLogicalGroupTable[] = {
+  eCSSProperty_height,
+  eCSSProperty_width,
+  eCSSProperty_UNKNOWN
+};
+
+const nsCSSPropertyID* const
+nsCSSProps::kLogicalGroupTable[eCSSPropertyLogicalGroup_COUNT] = {
+#define CSS_PROP_LOGICAL_GROUP_SHORTHAND(id_) g##id_##SubpropTable,
+#define CSS_PROP_LOGICAL_GROUP_AXIS(name_) g##name_##LogicalGroupTable,
+#define CSS_PROP_LOGICAL_GROUP_BOX(name_) g##name_##LogicalGroupTable,
+#include "nsCSSPropLogicalGroupList.h"
+#undef CSS_PROP_LOGICAL_GROUP_BOX
+#undef CSS_PROP_LOGICAL_GROUP_AXIS
+#undef CSS_PROP_LOGICAL_GROUP_SHORTHAND
+};
+
+// Mapping of logical longhand properties to their logical group (which
+// represents the physical longhands the logical properties an correspond
+// to).  The format is pairs of values, where the first is the logical
+// longhand property (an nsCSSPropertyID) and the second is the logical group
+// (an nsCSSPropertyLogicalGroup), stored in a flat array (like KTableEntry
+// arrays).
+static const int gLogicalGroupMappingTable[] = {
+#define CSS_PROP_LOGICAL(name_, id_, method_, flags_, pref_, parsevariant_, \
+                         kwtable_, group_, stylestruct_,                    \
+                         stylestructoffset_, animtype_)                     \
+  eCSSProperty_##id_, eCSSPropertyLogicalGroup_##group_,
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LOGICAL
+};
+
+/* static */ const nsCSSPropertyID*
+nsCSSProps::LogicalGroup(nsCSSPropertyID aProperty)
+{
+  MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
+             "out of range");
+  MOZ_ASSERT(nsCSSProps::PropHasFlags(aProperty, CSS_PROPERTY_LOGICAL),
+             "aProperty must be a logical longhand property");
+
+  for (size_t i = 0; i < ArrayLength(gLogicalGroupMappingTable); i += 2) {
+    if (gLogicalGroupMappingTable[i] == aProperty) {
+      return kLogicalGroupTable[gLogicalGroupMappingTable[i + 1]];
+    }
+  }
+
+  MOZ_ASSERT(false, "missing gLogicalGroupMappingTable entry");
+  return nullptr;
+}
+
+
+#define ENUM_DATA_FOR_PROPERTY(name_, id_, method_, flags_, pref_,          \
+                               parsevariant_, kwtable_, stylestructoffset_, \
+                               animtype_)                                   \
+  ePropertyIndex_for_##id_,
+
+// The order of these enums must match the g*Flags arrays in nsRuleNode.cpp.
+
+enum FontCheckCounter {
+  #define CSS_PROP_FONT ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_FONT
+  ePropertyCount_for_Font
+};
+
+enum DisplayCheckCounter {
+  #define CSS_PROP_DISPLAY ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_DISPLAY
+  ePropertyCount_for_Display
+};
+
+enum VisibilityCheckCounter {
+  #define CSS_PROP_VISIBILITY ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_VISIBILITY
+  ePropertyCount_for_Visibility
+};
+
+enum MarginCheckCounter {
+  #define CSS_PROP_MARGIN ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_MARGIN
+  ePropertyCount_for_Margin
+};
+
+enum BorderCheckCounter {
+  #define CSS_PROP_BORDER ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_BORDER
+  ePropertyCount_for_Border
+};
+
+enum PaddingCheckCounter {
+  #define CSS_PROP_PADDING ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_PADDING
+  ePropertyCount_for_Padding
+};
+
+enum OutlineCheckCounter {
+  #define CSS_PROP_OUTLINE ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_OUTLINE
+  ePropertyCount_for_Outline
+};
+
+enum ListCheckCounter {
+  #define CSS_PROP_LIST ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_LIST
+  ePropertyCount_for_List
+};
+
+enum ColorCheckCounter {
+  #define CSS_PROP_COLOR ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_COLOR
+  ePropertyCount_for_Color
+};
+
+enum BackgroundCheckCounter {
+  #define CSS_PROP_BACKGROUND ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_BACKGROUND
+  ePropertyCount_for_Background
+};
+
+enum PositionCheckCounter {
+  #define CSS_PROP_POSITION ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_POSITION
+  ePropertyCount_for_Position
+};
+
+enum TableCheckCounter {
+  #define CSS_PROP_TABLE ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_TABLE
+  ePropertyCount_for_Table
+};
+
+enum TableBorderCheckCounter {
+  #define CSS_PROP_TABLEBORDER ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_TABLEBORDER
+  ePropertyCount_for_TableBorder
+};
+
+enum ContentCheckCounter {
+  #define CSS_PROP_CONTENT ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_CONTENT
+  ePropertyCount_for_Content
+};
+
+enum TextCheckCounter {
+  #define CSS_PROP_TEXT ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_TEXT
+  ePropertyCount_for_Text
+};
+
+enum TextResetCheckCounter {
+  #define CSS_PROP_TEXTRESET ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_TEXTRESET
+  ePropertyCount_for_TextReset
+};
+
+enum UserInterfaceCheckCounter {
+  #define CSS_PROP_USERINTERFACE ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_USERINTERFACE
+  ePropertyCount_for_UserInterface
+};
+
+enum UIResetCheckCounter {
+  #define CSS_PROP_UIRESET ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_UIRESET
+  ePropertyCount_for_UIReset
+};
+
+enum XULCheckCounter {
+  #define CSS_PROP_XUL ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_XUL
+  ePropertyCount_for_XUL
+};
+
+enum SVGCheckCounter {
+  #define CSS_PROP_SVG ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_SVG
+  ePropertyCount_for_SVG
+};
+
+enum SVGResetCheckCounter {
+  #define CSS_PROP_SVGRESET ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_SVGRESET
+  ePropertyCount_for_SVGReset
+};
+
+enum ColumnCheckCounter {
+  #define CSS_PROP_COLUMN ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_COLUMN
+  ePropertyCount_for_Column
+};
+
+enum VariablesCheckCounter {
+  #define CSS_PROP_VARIABLES ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_VARIABLES
+  ePropertyCount_for_Variables
+};
+
+enum EffectsCheckCounter {
+  #define CSS_PROP_EFFECTS ENUM_DATA_FOR_PROPERTY
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_EFFECTS
+  ePropertyCount_for_Effects
+};
+
+#undef ENUM_DATA_FOR_PROPERTY
+
+/* static */ const size_t
+nsCSSProps::gPropertyCountInStruct[nsStyleStructID_Length] = {
+  #define STYLE_STRUCT(name, checkdata_cb) \
+    ePropertyCount_for_##name,
+  #include "nsStyleStructList.h"
+  #undef STYLE_STRUCT
+};
+
+/* static */ const size_t
+nsCSSProps::gPropertyIndexInStruct[eCSSProperty_COUNT_no_shorthands] = {
+
+  #define CSS_PROP_LOGICAL(name_, id_, method_, flags_, pref_, parsevariant_, \
+                           kwtable_, group_, stylestruct_,                    \
+                           stylestructoffset_, animtype_)                     \
+      size_t(-1),
+  #define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_,     \
+                   kwtable_, stylestruct_, stylestructoffset_, animtype_) \
+    ePropertyIndex_for_##id_,
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP
+  #undef CSS_PROP_LOGICAL
+
+};
+
+/* static */ bool
+nsCSSProps::gPropertyEnabled[eCSSProperty_COUNT_with_aliases] = {
+  // If the property has any "ENABLED_IN" flag set, it is disabled by
+  // default. Note that, if a property has pref, whatever its default
+  // value is, it will later be changed in nsCSSProps::AddRefTable().
+  // If the property has "ENABLED_IN" flags but doesn't have a pref,
+  // it is an internal property which is disabled elsewhere.
+  #define IS_ENABLED_BY_DEFAULT(flags_) \
+    (!((flags_) & CSS_PROPERTY_ENABLED_MASK))
+
+  #define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_,     \
+                   kwtable_, stylestruct_, stylestructoffset_, animtype_) \
+    IS_ENABLED_BY_DEFAULT(flags_),
+  #define CSS_PROP_LIST_INCLUDE_LOGICAL
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_LIST_INCLUDE_LOGICAL
+  #undef CSS_PROP
+
+  #define  CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) \
+    IS_ENABLED_BY_DEFAULT(flags_),
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_SHORTHAND
+
+  #define CSS_PROP_ALIAS(aliasname_, propid_, aliasmethod_, pref_) \
+    true,
+  #include "nsCSSPropAliasList.h"
+  #undef CSS_PROP_ALIAS
+
+  #undef IS_ENABLED_BY_DEFAULT
+};
+
+#include "../../dom/base/PropertyUseCounterMap.inc"
+
+/* static */ const UseCounter
+nsCSSProps::gPropertyUseCounter[eCSSProperty_COUNT_no_shorthands] = {
+  #define CSS_PROP_PUBLIC_OR_PRIVATE(publicname_, privatename_) privatename_
+  #define CSS_PROP_LIST_INCLUDE_LOGICAL
+  #define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_,     \
+                   kwtable_, stylestruct_, stylestructoffset_, animtype_) \
+    static_cast<UseCounter>(USE_COUNTER_FOR_CSS_PROPERTY_##method_),
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP
+  #undef CSS_PROP_LIST_INCLUDE_LOGICAL
+  #undef CSS_PROP_PUBLIC_OR_PRIVATE
+};
+
+// Check that all logical property flags are used appropriately.
+#define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_,         \
+                 kwtable_, stylestruct_, stylestructoffset_, animtype_)     \
+  static_assert(!((flags_) & CSS_PROPERTY_LOGICAL),                         \
+                "only properties defined with CSS_PROP_LOGICAL can use "    \
+                "the CSS_PROPERTY_LOGICAL flag");                           \
+  static_assert(!((flags_) & CSS_PROPERTY_LOGICAL_AXIS),                    \
+                "only properties defined with CSS_PROP_LOGICAL can use "    \
+                "the CSS_PROPERTY_LOGICAL_AXIS flag");                      \
+  static_assert(!((flags_) & CSS_PROPERTY_LOGICAL_BLOCK_AXIS),              \
+                "only properties defined with CSS_PROP_LOGICAL can use "    \
+                "the CSS_PROPERTY_LOGICAL_BLOCK_AXIS flag");                \
+  static_assert(!((flags_) & CSS_PROPERTY_LOGICAL_END_EDGE),                \
+                "only properties defined with CSS_PROP_LOGICAL can use "    \
+                "the CSS_PROPERTY_LOGICAL_END_EDGE flag");
+#define CSS_PROP_LOGICAL(name_, id_, method_, flags_, pref_, parsevariant_, \
+                         kwtable_, group_, stylestruct_,                    \
+                         stylestructoffset_, animtype_)                     \
+  static_assert((flags_) & CSS_PROPERTY_LOGICAL,                            \
+                "properties defined with CSS_PROP_LOGICAL must also use "   \
+                "the CSS_PROPERTY_LOGICAL flag");                           \
+  static_assert(!((flags_) & CSS_PROPERTY_IGNORED_WHEN_COLORS_DISABLED),    \
+                "CSS_PROPERTY_IGNORED_WHEN_COLORS_DISABLED has no effect "  \
+                "on logical properties");                                   \
+  static_assert(!(((flags_) & CSS_PROPERTY_LOGICAL_AXIS) &&                 \
+                  ((flags_) & CSS_PROPERTY_LOGICAL_END_EDGE)),              \
+                "CSS_PROPERTY_LOGICAL_END_EDGE makes no sense when used "   \
+                "with CSS_PROPERTY_LOGICAL_AXIS");
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LOGICAL
+#undef CSS_PROP
+
+#include "nsCSSPropsGenerated.inc"