@yahoo/uds 3.59.0-beta.1 → 3.60.0

package/dist/fixtures.js

@@ -1,3 +1,818 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+    target = mod != null ? __create(__getProtoOf(mod)) : {};
+    const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+    for (let key of __getOwnPropNames(mod))
+        if (!__hasOwnProp.call(to, key))
+            __defProp(to, key, {
+                get: () => mod[key],
+                enumerable: true
+            });
+    return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+// ../../node_modules/lodash/_freeGlobal.js
+var require__freeGlobal = __commonJS((exports, module) => {
+    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+    module.exports = freeGlobal;
+});
+// ../../node_modules/lodash/_root.js
+var require__root = __commonJS((exports, module) => {
+    var freeGlobal = require__freeGlobal();
+    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+    var root = freeGlobal || freeSelf || Function("return this")();
+    module.exports = root;
+});
+// ../../node_modules/lodash/_Symbol.js
+var require__Symbol = __commonJS((exports, module) => {
+    var root = require__root();
+    var Symbol2 = root.Symbol;
+    module.exports = Symbol2;
+});
+// ../../node_modules/lodash/_getRawTag.js
+var require__getRawTag = __commonJS((exports, module) => {
+    var Symbol2 = require__Symbol();
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var nativeObjectToString = objectProto.toString;
+    var symToStringTag = Symbol2 ? Symbol2.toStringTag : undefined;
+    function getRawTag(value) {
+        var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+        try {
+            value[symToStringTag] = undefined;
+            var unmasked = true;
+        }
+        catch (e) { }
+        var result = nativeObjectToString.call(value);
+        if (unmasked) {
+            if (isOwn) {
+                value[symToStringTag] = tag;
+            }
+            else {
+                delete value[symToStringTag];
+            }
+        }
+        return result;
+    }
+    module.exports = getRawTag;
+});
+// ../../node_modules/lodash/_objectToString.js
+var require__objectToString = __commonJS((exports, module) => {
+    var objectProto = Object.prototype;
+    var nativeObjectToString = objectProto.toString;
+    function objectToString(value) {
+        return nativeObjectToString.call(value);
+    }
+    module.exports = objectToString;
+});
+// ../../node_modules/lodash/_baseGetTag.js
+var require__baseGetTag = __commonJS((exports, module) => {
+    var Symbol2 = require__Symbol();
+    var getRawTag = require__getRawTag();
+    var objectToString = require__objectToString();
+    var nullTag = "[object Null]";
+    var undefinedTag = "[object Undefined]";
+    var symToStringTag = Symbol2 ? Symbol2.toStringTag : undefined;
+    function baseGetTag(value) {
+        if (value == null) {
+            return value === undefined ? undefinedTag : nullTag;
+        }
+        return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+    }
+    module.exports = baseGetTag;
+});
+// ../../node_modules/lodash/isObject.js
+var require_isObject = __commonJS((exports, module) => {
+    function isObject(value) {
+        var type = typeof value;
+        return value != null && (type == "object" || type == "function");
+    }
+    module.exports = isObject;
+});
+// ../../node_modules/lodash/isFunction.js
+var require_isFunction = __commonJS((exports, module) => {
+    var baseGetTag = require__baseGetTag();
+    var isObject = require_isObject();
+    var asyncTag = "[object AsyncFunction]";
+    var funcTag = "[object Function]";
+    var genTag = "[object GeneratorFunction]";
+    var proxyTag = "[object Proxy]";
+    function isFunction(value) {
+        if (!isObject(value)) {
+            return false;
+        }
+        var tag = baseGetTag(value);
+        return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+    }
+    module.exports = isFunction;
+});
+// ../../node_modules/lodash/_coreJsData.js
+var require__coreJsData = __commonJS((exports, module) => {
+    var root = require__root();
+    var coreJsData = root["__core-js_shared__"];
+    module.exports = coreJsData;
+});
+// ../../node_modules/lodash/_isMasked.js
+var require__isMasked = __commonJS((exports, module) => {
+    var coreJsData = require__coreJsData();
+    var maskSrcKey = function () {
+        var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+        return uid ? "Symbol(src)_1." + uid : "";
+    }();
+    function isMasked(func) {
+        return !!maskSrcKey && maskSrcKey in func;
+    }
+    module.exports = isMasked;
+});
+// ../../node_modules/lodash/_toSource.js
+var require__toSource = __commonJS((exports, module) => {
+    var funcProto = Function.prototype;
+    var funcToString = funcProto.toString;
+    function toSource(func) {
+        if (func != null) {
+            try {
+                return funcToString.call(func);
+            }
+            catch (e) { }
+            try {
+                return func + "";
+            }
+            catch (e) { }
+        }
+        return "";
+    }
+    module.exports = toSource;
+});
+// ../../node_modules/lodash/_baseIsNative.js
+var require__baseIsNative = __commonJS((exports, module) => {
+    var isFunction = require_isFunction();
+    var isMasked = require__isMasked();
+    var isObject = require_isObject();
+    var toSource = require__toSource();
+    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+    var reIsHostCtor = /^\[object .+?Constructor\]$/;
+    var funcProto = Function.prototype;
+    var objectProto = Object.prototype;
+    var funcToString = funcProto.toString;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+    function baseIsNative(value) {
+        if (!isObject(value) || isMasked(value)) {
+            return false;
+        }
+        var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+        return pattern.test(toSource(value));
+    }
+    module.exports = baseIsNative;
+});
+// ../../node_modules/lodash/_getValue.js
+var require__getValue = __commonJS((exports, module) => {
+    function getValue(object, key) {
+        return object == null ? undefined : object[key];
+    }
+    module.exports = getValue;
+});
+// ../../node_modules/lodash/_getNative.js
+var require__getNative = __commonJS((exports, module) => {
+    var baseIsNative = require__baseIsNative();
+    var getValue = require__getValue();
+    function getNative(object, key) {
+        var value = getValue(object, key);
+        return baseIsNative(value) ? value : undefined;
+    }
+    module.exports = getNative;
+});
+// ../../node_modules/lodash/_nativeCreate.js
+var require__nativeCreate = __commonJS((exports, module) => {
+    var getNative = require__getNative();
+    var nativeCreate = getNative(Object, "create");
+    module.exports = nativeCreate;
+});
+// ../../node_modules/lodash/_hashClear.js
+var require__hashClear = __commonJS((exports, module) => {
+    var nativeCreate = require__nativeCreate();
+    function hashClear() {
+        this.__data__ = nativeCreate ? nativeCreate(null) : {};
+        this.size = 0;
+    }
+    module.exports = hashClear;
+});
+// ../../node_modules/lodash/_hashDelete.js
+var require__hashDelete = __commonJS((exports, module) => {
+    function hashDelete(key) {
+        var result = this.has(key) && delete this.__data__[key];
+        this.size -= result ? 1 : 0;
+        return result;
+    }
+    module.exports = hashDelete;
+});
+// ../../node_modules/lodash/_hashGet.js
+var require__hashGet = __commonJS((exports, module) => {
+    var nativeCreate = require__nativeCreate();
+    var HASH_UNDEFINED = "__lodash_hash_undefined__";
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    function hashGet(key) {
+        var data = this.__data__;
+        if (nativeCreate) {
+            var result = data[key];
+            return result === HASH_UNDEFINED ? undefined : result;
+        }
+        return hasOwnProperty.call(data, key) ? data[key] : undefined;
+    }
+    module.exports = hashGet;
+});
+// ../../node_modules/lodash/_hashHas.js
+var require__hashHas = __commonJS((exports, module) => {
+    var nativeCreate = require__nativeCreate();
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    function hashHas(key) {
+        var data = this.__data__;
+        return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+    }
+    module.exports = hashHas;
+});
+// ../../node_modules/lodash/_hashSet.js
+var require__hashSet = __commonJS((exports, module) => {
+    var nativeCreate = require__nativeCreate();
+    var HASH_UNDEFINED = "__lodash_hash_undefined__";
+    function hashSet(key, value) {
+        var data = this.__data__;
+        this.size += this.has(key) ? 0 : 1;
+        data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
+        return this;
+    }
+    module.exports = hashSet;
+});
+// ../../node_modules/lodash/_Hash.js
+var require__Hash = __commonJS((exports, module) => {
+    var hashClear = require__hashClear();
+    var hashDelete = require__hashDelete();
+    var hashGet = require__hashGet();
+    var hashHas = require__hashHas();
+    var hashSet = require__hashSet();
+    function Hash(entries) {
+        var index = -1, length = entries == null ? 0 : entries.length;
+        this.clear();
+        while (++index < length) {
+            var entry = entries[index];
+            this.set(entry[0], entry[1]);
+        }
+    }
+    Hash.prototype.clear = hashClear;
+    Hash.prototype["delete"] = hashDelete;
+    Hash.prototype.get = hashGet;
+    Hash.prototype.has = hashHas;
+    Hash.prototype.set = hashSet;
+    module.exports = Hash;
+});
+// ../../node_modules/lodash/_listCacheClear.js
+var require__listCacheClear = __commonJS((exports, module) => {
+    function listCacheClear() {
+        this.__data__ = [];
+        this.size = 0;
+    }
+    module.exports = listCacheClear;
+});
+// ../../node_modules/lodash/eq.js
+var require_eq = __commonJS((exports, module) => {
+    function eq(value, other) {
+        return value === other || value !== value && other !== other;
+    }
+    module.exports = eq;
+});
+// ../../node_modules/lodash/_assocIndexOf.js
+var require__assocIndexOf = __commonJS((exports, module) => {
+    var eq = require_eq();
+    function assocIndexOf(array, key) {
+        var length = array.length;
+        while (length--) {
+            if (eq(array[length][0], key)) {
+                return length;
+            }
+        }
+        return -1;
+    }
+    module.exports = assocIndexOf;
+});
+// ../../node_modules/lodash/_listCacheDelete.js
+var require__listCacheDelete = __commonJS((exports, module) => {
+    var assocIndexOf = require__assocIndexOf();
+    var arrayProto = Array.prototype;
+    var splice = arrayProto.splice;
+    function listCacheDelete(key) {
+        var data = this.__data__, index = assocIndexOf(data, key);
+        if (index < 0) {
+            return false;
+        }
+        var lastIndex = data.length - 1;
+        if (index == lastIndex) {
+            data.pop();
+        }
+        else {
+            splice.call(data, index, 1);
+        }
+        --this.size;
+        return true;
+    }
+    module.exports = listCacheDelete;
+});
+// ../../node_modules/lodash/_listCacheGet.js
+var require__listCacheGet = __commonJS((exports, module) => {
+    var assocIndexOf = require__assocIndexOf();
+    function listCacheGet(key) {
+        var data = this.__data__, index = assocIndexOf(data, key);
+        return index < 0 ? undefined : data[index][1];
+    }
+    module.exports = listCacheGet;
+});
+// ../../node_modules/lodash/_listCacheHas.js
+var require__listCacheHas = __commonJS((exports, module) => {
+    var assocIndexOf = require__assocIndexOf();
+    function listCacheHas(key) {
+        return assocIndexOf(this.__data__, key) > -1;
+    }
+    module.exports = listCacheHas;
+});
+// ../../node_modules/lodash/_listCacheSet.js
+var require__listCacheSet = __commonJS((exports, module) => {
+    var assocIndexOf = require__assocIndexOf();
+    function listCacheSet(key, value) {
+        var data = this.__data__, index = assocIndexOf(data, key);
+        if (index < 0) {
+            ++this.size;
+            data.push([key, value]);
+        }
+        else {
+            data[index][1] = value;
+        }
+        return this;
+    }
+    module.exports = listCacheSet;
+});
+// ../../node_modules/lodash/_ListCache.js
+var require__ListCache = __commonJS((exports, module) => {
+    var listCacheClear = require__listCacheClear();
+    var listCacheDelete = require__listCacheDelete();
+    var listCacheGet = require__listCacheGet();
+    var listCacheHas = require__listCacheHas();
+    var listCacheSet = require__listCacheSet();
+    function ListCache(entries) {
+        var index = -1, length = entries == null ? 0 : entries.length;
+        this.clear();
+        while (++index < length) {
+            var entry = entries[index];
+            this.set(entry[0], entry[1]);
+        }
+    }
+    ListCache.prototype.clear = listCacheClear;
+    ListCache.prototype["delete"] = listCacheDelete;
+    ListCache.prototype.get = listCacheGet;
+    ListCache.prototype.has = listCacheHas;
+    ListCache.prototype.set = listCacheSet;
+    module.exports = ListCache;
+});
+// ../../node_modules/lodash/_Map.js
+var require__Map = __commonJS((exports, module) => {
+    var getNative = require__getNative();
+    var root = require__root();
+    var Map = getNative(root, "Map");
+    module.exports = Map;
+});
+// ../../node_modules/lodash/_mapCacheClear.js
+var require__mapCacheClear = __commonJS((exports, module) => {
+    var Hash = require__Hash();
+    var ListCache = require__ListCache();
+    var Map = require__Map();
+    function mapCacheClear() {
+        this.size = 0;
+        this.__data__ = {
+            hash: new Hash,
+            map: new (Map || ListCache),
+            string: new Hash
+        };
+    }
+    module.exports = mapCacheClear;
+});
+// ../../node_modules/lodash/_isKeyable.js
+var require__isKeyable = __commonJS((exports, module) => {
+    function isKeyable(value) {
+        var type = typeof value;
+        return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+    }
+    module.exports = isKeyable;
+});
+// ../../node_modules/lodash/_getMapData.js
+var require__getMapData = __commonJS((exports, module) => {
+    var isKeyable = require__isKeyable();
+    function getMapData(map, key) {
+        var data = map.__data__;
+        return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+    }
+    module.exports = getMapData;
+});
+// ../../node_modules/lodash/_mapCacheDelete.js
+var require__mapCacheDelete = __commonJS((exports, module) => {
+    var getMapData = require__getMapData();
+    function mapCacheDelete(key) {
+        var result = getMapData(this, key)["delete"](key);
+        this.size -= result ? 1 : 0;
+        return result;
+    }
+    module.exports = mapCacheDelete;
+});
+// ../../node_modules/lodash/_mapCacheGet.js
+var require__mapCacheGet = __commonJS((exports, module) => {
+    var getMapData = require__getMapData();
+    function mapCacheGet(key) {
+        return getMapData(this, key).get(key);
+    }
+    module.exports = mapCacheGet;
+});
+// ../../node_modules/lodash/_mapCacheHas.js
+var require__mapCacheHas = __commonJS((exports, module) => {
+    var getMapData = require__getMapData();
+    function mapCacheHas(key) {
+        return getMapData(this, key).has(key);
+    }
+    module.exports = mapCacheHas;
+});
+// ../../node_modules/lodash/_mapCacheSet.js
+var require__mapCacheSet = __commonJS((exports, module) => {
+    var getMapData = require__getMapData();
+    function mapCacheSet(key, value) {
+        var data = getMapData(this, key), size = data.size;
+        data.set(key, value);
+        this.size += data.size == size ? 0 : 1;
+        return this;
+    }
+    module.exports = mapCacheSet;
+});
+// ../../node_modules/lodash/_MapCache.js
+var require__MapCache = __commonJS((exports, module) => {
+    var mapCacheClear = require__mapCacheClear();
+    var mapCacheDelete = require__mapCacheDelete();
+    var mapCacheGet = require__mapCacheGet();
+    var mapCacheHas = require__mapCacheHas();
+    var mapCacheSet = require__mapCacheSet();
+    function MapCache(entries) {
+        var index = -1, length = entries == null ? 0 : entries.length;
+        this.clear();
+        while (++index < length) {
+            var entry = entries[index];
+            this.set(entry[0], entry[1]);
+        }
+    }
+    MapCache.prototype.clear = mapCacheClear;
+    MapCache.prototype["delete"] = mapCacheDelete;
+    MapCache.prototype.get = mapCacheGet;
+    MapCache.prototype.has = mapCacheHas;
+    MapCache.prototype.set = mapCacheSet;
+    module.exports = MapCache;
+});
+// ../../node_modules/lodash/_setCacheAdd.js
+var require__setCacheAdd = __commonJS((exports, module) => {
+    var HASH_UNDEFINED = "__lodash_hash_undefined__";
+    function setCacheAdd(value) {
+        this.__data__.set(value, HASH_UNDEFINED);
+        return this;
+    }
+    module.exports = setCacheAdd;
+});
+// ../../node_modules/lodash/_setCacheHas.js
+var require__setCacheHas = __commonJS((exports, module) => {
+    function setCacheHas(value) {
+        return this.__data__.has(value);
+    }
+    module.exports = setCacheHas;
+});
+// ../../node_modules/lodash/_SetCache.js
+var require__SetCache = __commonJS((exports, module) => {
+    var MapCache = require__MapCache();
+    var setCacheAdd = require__setCacheAdd();
+    var setCacheHas = require__setCacheHas();
+    function SetCache(values) {
+        var index = -1, length = values == null ? 0 : values.length;
+        this.__data__ = new MapCache;
+        while (++index < length) {
+            this.add(values[index]);
+        }
+    }
+    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+    SetCache.prototype.has = setCacheHas;
+    module.exports = SetCache;
+});
+// ../../node_modules/lodash/_baseFindIndex.js
+var require__baseFindIndex = __commonJS((exports, module) => {
+    function baseFindIndex(array, predicate, fromIndex, fromRight) {
+        var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
+        while (fromRight ? index-- : ++index < length) {
+            if (predicate(array[index], index, array)) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    module.exports = baseFindIndex;
+});
+// ../../node_modules/lodash/_baseIsNaN.js
+var require__baseIsNaN = __commonJS((exports, module) => {
+    function baseIsNaN(value) {
+        return value !== value;
+    }
+    module.exports = baseIsNaN;
+});
+// ../../node_modules/lodash/_strictIndexOf.js
+var require__strictIndexOf = __commonJS((exports, module) => {
+    function strictIndexOf(array, value, fromIndex) {
+        var index = fromIndex - 1, length = array.length;
+        while (++index < length) {
+            if (array[index] === value) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    module.exports = strictIndexOf;
+});
+// ../../node_modules/lodash/_baseIndexOf.js
+var require__baseIndexOf = __commonJS((exports, module) => {
+    var baseFindIndex = require__baseFindIndex();
+    var baseIsNaN = require__baseIsNaN();
+    var strictIndexOf = require__strictIndexOf();
+    function baseIndexOf(array, value, fromIndex) {
+        return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
+    }
+    module.exports = baseIndexOf;
+});
+// ../../node_modules/lodash/_arrayIncludes.js
+var require__arrayIncludes = __commonJS((exports, module) => {
+    var baseIndexOf = require__baseIndexOf();
+    function arrayIncludes(array, value) {
+        var length = array == null ? 0 : array.length;
+        return !!length && baseIndexOf(array, value, 0) > -1;
+    }
+    module.exports = arrayIncludes;
+});
+// ../../node_modules/lodash/_arrayIncludesWith.js
+var require__arrayIncludesWith = __commonJS((exports, module) => {
+    function arrayIncludesWith(array, value, comparator) {
+        var index = -1, length = array == null ? 0 : array.length;
+        while (++index < length) {
+            if (comparator(value, array[index])) {
+                return true;
+            }
+        }
+        return false;
+    }
+    module.exports = arrayIncludesWith;
+});
+// ../../node_modules/lodash/_arrayMap.js
+var require__arrayMap = __commonJS((exports, module) => {
+    function arrayMap(array, iteratee) {
+        var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+        while (++index < length) {
+            result[index] = iteratee(array[index], index, array);
+        }
+        return result;
+    }
+    module.exports = arrayMap;
+});
+// ../../node_modules/lodash/_baseUnary.js
+var require__baseUnary = __commonJS((exports, module) => {
+    function baseUnary(func) {
+        return function (value) {
+            return func(value);
+        };
+    }
+    module.exports = baseUnary;
+});
+// ../../node_modules/lodash/_cacheHas.js
+var require__cacheHas = __commonJS((exports, module) => {
+    function cacheHas(cache, key) {
+        return cache.has(key);
+    }
+    module.exports = cacheHas;
+});
+// ../../node_modules/lodash/_baseDifference.js
+var require__baseDifference = __commonJS((exports, module) => {
+    var SetCache = require__SetCache();
+    var arrayIncludes = require__arrayIncludes();
+    var arrayIncludesWith = require__arrayIncludesWith();
+    var arrayMap = require__arrayMap();
+    var baseUnary = require__baseUnary();
+    var cacheHas = require__cacheHas();
+    var LARGE_ARRAY_SIZE = 200;
+    function baseDifference(array, values, iteratee, comparator) {
+        var index = -1, includes = arrayIncludes, isCommon = true, length = array.length, result = [], valuesLength = values.length;
+        if (!length) {
+            return result;
+        }
+        if (iteratee) {
+            values = arrayMap(values, baseUnary(iteratee));
+        }
+        if (comparator) {
+            includes = arrayIncludesWith;
+            isCommon = false;
+        }
+        else if (values.length >= LARGE_ARRAY_SIZE) {
+            includes = cacheHas;
+            isCommon = false;
+            values = new SetCache(values);
+        }
+        outer: while (++index < length) {
+            var value = array[index], computed = iteratee == null ? value : iteratee(value);
+            value = comparator || value !== 0 ? value : 0;
+            if (isCommon && computed === computed) {
+                var valuesIndex = valuesLength;
+                while (valuesIndex--) {
+                    if (values[valuesIndex] === computed) {
+                        continue outer;
+                    }
+                }
+                result.push(value);
+            }
+            else if (!includes(values, computed, comparator)) {
+                result.push(value);
+            }
+        }
+        return result;
+    }
+    module.exports = baseDifference;
+});
+// ../../node_modules/lodash/identity.js
+var require_identity = __commonJS((exports, module) => {
+    function identity(value) {
+        return value;
+    }
+    module.exports = identity;
+});
+// ../../node_modules/lodash/_apply.js
+var require__apply = __commonJS((exports, module) => {
+    function apply(func, thisArg, args) {
+        switch (args.length) {
+            case 0:
+                return func.call(thisArg);
+            case 1:
+                return func.call(thisArg, args[0]);
+            case 2:
+                return func.call(thisArg, args[0], args[1]);
+            case 3:
+                return func.call(thisArg, args[0], args[1], args[2]);
+        }
+        return func.apply(thisArg, args);
+    }
+    module.exports = apply;
+});
+// ../../node_modules/lodash/_overRest.js
+var require__overRest = __commonJS((exports, module) => {
+    var apply = require__apply();
+    var nativeMax = Math.max;
+    function overRest(func, start, transform) {
+        start = nativeMax(start === undefined ? func.length - 1 : start, 0);
+        return function () {
+            var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
+            while (++index < length) {
+                array[index] = args[start + index];
+            }
+            index = -1;
+            var otherArgs = Array(start + 1);
+            while (++index < start) {
+                otherArgs[index] = args[index];
+            }
+            otherArgs[start] = transform(array);
+            return apply(func, this, otherArgs);
+        };
+    }
+    module.exports = overRest;
+});
+// ../../node_modules/lodash/constant.js
+var require_constant = __commonJS((exports, module) => {
+    function constant(value) {
+        return function () {
+            return value;
+        };
+    }
+    module.exports = constant;
+});
+// ../../node_modules/lodash/_defineProperty.js
+var require__defineProperty = __commonJS((exports, module) => {
+    var getNative = require__getNative();
+    var defineProperty = function () {
+        try {
+            var func = getNative(Object, "defineProperty");
+            func({}, "", {});
+            return func;
+        }
+        catch (e) { }
+    }();
+    module.exports = defineProperty;
+});
+// ../../node_modules/lodash/_baseSetToString.js
+var require__baseSetToString = __commonJS((exports, module) => {
+    var constant = require_constant();
+    var defineProperty = require__defineProperty();
+    var identity = require_identity();
+    var baseSetToString = !defineProperty ? identity : function (func, string) {
+        return defineProperty(func, "toString", {
+            configurable: true,
+            enumerable: false,
+            value: constant(string),
+            writable: true
+        });
+    };
+    module.exports = baseSetToString;
+});
+// ../../node_modules/lodash/_shortOut.js
+var require__shortOut = __commonJS((exports, module) => {
+    var HOT_COUNT = 800;
+    var HOT_SPAN = 16;
+    var nativeNow = Date.now;
+    function shortOut(func) {
+        var count = 0, lastCalled = 0;
+        return function () {
+            var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
+            lastCalled = stamp;
+            if (remaining > 0) {
+                if (++count >= HOT_COUNT) {
+                    return arguments[0];
+                }
+            }
+            else {
+                count = 0;
+            }
+            return func.apply(undefined, arguments);
+        };
+    }
+    module.exports = shortOut;
+});
+// ../../node_modules/lodash/_setToString.js
+var require__setToString = __commonJS((exports, module) => {
+    var baseSetToString = require__baseSetToString();
+    var shortOut = require__shortOut();
+    var setToString = shortOut(baseSetToString);
+    module.exports = setToString;
+});
+// ../../node_modules/lodash/_baseRest.js
+var require__baseRest = __commonJS((exports, module) => {
+    var identity = require_identity();
+    var overRest = require__overRest();
+    var setToString = require__setToString();
+    function baseRest(func, start) {
+        return setToString(overRest(func, start, identity), func + "");
+    }
+    module.exports = baseRest;
+});
+// ../../node_modules/lodash/isLength.js
+var require_isLength = __commonJS((exports, module) => {
+    var MAX_SAFE_INTEGER = 9007199254740991;
+    function isLength(value) {
+        return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+    }
+    module.exports = isLength;
+});
+// ../../node_modules/lodash/isArrayLike.js
+var require_isArrayLike = __commonJS((exports, module) => {
+    var isFunction = require_isFunction();
+    var isLength = require_isLength();
+    function isArrayLike(value) {
+        return value != null && isLength(value.length) && !isFunction(value);
+    }
+    module.exports = isArrayLike;
+});
+// ../../node_modules/lodash/isObjectLike.js
+var require_isObjectLike = __commonJS((exports, module) => {
+    function isObjectLike(value) {
+        return value != null && typeof value == "object";
+    }
+    module.exports = isObjectLike;
+});
+// ../../node_modules/lodash/isArrayLikeObject.js
+var require_isArrayLikeObject = __commonJS((exports, module) => {
+    var isArrayLike = require_isArrayLike();
+    var isObjectLike = require_isObjectLike();
+    function isArrayLikeObject(value) {
+        return isObjectLike(value) && isArrayLike(value);
+    }
+    module.exports = isArrayLikeObject;
+});
+// ../../node_modules/lodash/without.js
+var require_without = __commonJS((exports, module) => {
+    var baseDifference = require__baseDifference();
+    var baseRest = require__baseRest();
+    var isArrayLikeObject = require_isArrayLikeObject();
+    var without = baseRest(function (array, values) {
+        return isArrayLikeObject(array) ? baseDifference(array, values) : [];
+    });
+    module.exports = without;
+});
+// src/fixtures/index.ts
+var import_without = __toESM(require_without(), 1);
 // src/tokens/utils/fromEntries.ts
 function fromEntries(item) {
     return Object.fromEntries(item);
@@ -1198,7 +2013,8 @@ var textProperties = [
     "fontSize",
     "fontWeight",
     "lineHeight",
-    "textTransform"
+    "textTransform",
+    "letterSpacing"
 ];
 var textDecorationLines = [
     "none",
@@ -1210,6 +2026,7 @@ var typographyStyleProperties = [
     "fontWeight",
     "lineHeight",
     "textTransform",
+    "letterSpacing",
     "fontSlant",
     "fontWidth"
 ];
@@ -1979,7 +2796,7 @@ var buttonVariantsFlat = [
 });
 var buttonVariantsSecondary = buttonVariantsFlat.filter((variant) => variant.includes("secondary"));
 var buttonVariantsTertiary = buttonVariantsFlat.filter((variant) => variant.includes("tertiary"));
-var buttonVariantsPrimary = buttonVariantsFlat.filter((variant) => !buttonVariantsSecondary.includes(variant) && !buttonVariantsTertiary.includes(variant));
+var buttonVariantsPrimary = import_without.default(buttonVariantsFlat, ...buttonVariantsSecondary, ...buttonVariantsTertiary);
 var buttonPalettes = [
     "accent",
     "brand",
@@ -2063,7 +2880,7 @@ var buttonMotionProperties = [
     "trimLeft",
     "trimRight",
     "matchAll",
-    "__@iterator@74",
+    "__@iterator@84",
     "at"
 ];
 var buttonMotionEffects = [