@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/styled-system/css/conditions.js

@@ -0,0 +1,34 @@
+import { withoutSpace } from "../helpers.js";
+
+
+const conditionsStr = "_mobile,_narrowLandscape,_touchDevice,_hover,_focusVisible,_active,base";
+const conditions = new Set(conditionsStr.split(','));
+const conditionRegex = /^@|&|&$/;
+function isCondition(value) {
+    return conditions.has(value) || conditionRegex.test(value);
+}
+const underscoreRegex = /^_/;
+const conditionsSelectorRegex = /&|@/;
+function finalizeConditions(paths) {
+    return paths.map((path)=>{
+        if (conditions.has(path)) {
+            return path.replace(underscoreRegex, '');
+        }
+        if (conditionsSelectorRegex.test(path)) {
+            return "[" + withoutSpace(path.trim()) + "]";
+        }
+        return path;
+    });
+}
+function sortConditions(paths) {
+    return paths.sort((a, b)=>{
+        const aa = isCondition(a);
+        const bb = isCondition(b);
+        if (aa && !bb) return 1;
+        if (!aa && bb) return -1;
+        return 0;
+    });
+}
+
+var conditions_isCondition = /* unused export */ undefined;
+export { conditions_isCondition as isCondition, finalizeConditions, sortConditions };

package/widget/multimodal_v2/styled-system/css/css.js

@@ -0,0 +1,48 @@
+import { createCss, hypenateProperty, createMergeCss, withoutSpace } from "../helpers.js";
+import { sortConditions, finalizeConditions } from "./conditions.js";
+
+
+
+const utilities = "";
+const classNameByProp = new Map();
+utilities.split(',').forEach((utility)=>{
+    const [prop, className] = utility.split(':');
+    classNameByProp.set(prop, className);
+});
+const context = {
+    hash: true,
+    conditions: {
+        shift: sortConditions,
+        finalize: finalizeConditions,
+        breakpoints: {
+            keys: [
+                "base"
+            ]
+        }
+    },
+    utility: {
+        prefix: "q",
+        transform: (key, value)=>({
+                className: (classNameByProp.get(key) || hypenateProperty(key)) + "_" + withoutSpace(value)
+            }),
+        toHash: (path, hashFn)=>hashFn(path.join(":")),
+        resolveShorthand: (prop)=>prop
+    }
+};
+const cssFn = createCss(context);
+const css_css = function css() {
+    for(var _len = arguments.length, styles = new Array(_len), _key = 0; _key < _len; _key++){
+        styles[_key] = arguments[_key];
+    }
+    return cssFn(mergeCss(...styles));
+};
+css_css.raw = function() {
+    for(var _len = arguments.length, styles = new Array(_len), _key = 0; _key < _len; _key++){
+        styles[_key] = arguments[_key];
+    }
+    return mergeCss(...styles);
+};
+const { mergeCss: mergeCss, assignCss: assignCss } = createMergeCss(context);
+
+var css_assignCss = /* unused export */ undefined;
+export { css_assignCss as assignCss, css_css as css, mergeCss };

package/widget/multimodal_v2/styled-system/css/cva.js

@@ -0,0 +1,96 @@
+import { uniq as helpers_uniq, memo, mergeProps, splitProps, compact } from "../helpers.js";
+import { css as css_css, mergeCss } from "./css.js";
+import { _extends } from "../../../../js/4101.js";
+
+
+
+
+const defaults = (conf)=>_extends({
+        base: {},
+        variants: {},
+        defaultVariants: {},
+        compoundVariants: []
+    }, conf);
+function cva(config) {
+    const { base, variants, defaultVariants, compoundVariants } = defaults(config);
+    const getVariantProps = (variants)=>_extends({}, defaultVariants, compact(variants));
+    function resolve(props) {
+        if (props === void 0) props = {};
+        const computedVariants = getVariantProps(props);
+        let variantCss = _extends({}, base);
+        for (const [key, value] of Object.entries(computedVariants)){
+            var _variants_key;
+            if ((_variants_key = variants[key]) == null ? void 0 : _variants_key[value]) {
+                variantCss = mergeCss(variantCss, variants[key][value]);
+            }
+        }
+        const compoundVariantCss = getCompoundVariantCss(compoundVariants, computedVariants);
+        return mergeCss(variantCss, compoundVariantCss);
+    }
+    function merge(__cva) {
+        const override = defaults(__cva.config);
+        const variantKeys = helpers_uniq(__cva.variantKeys, Object.keys(variants));
+        return cva({
+            base: mergeCss(base, override.base),
+            variants: Object.fromEntries(variantKeys.map((key)=>[
+                    key,
+                    mergeCss(variants[key], override.variants[key])
+                ])),
+            defaultVariants: mergeProps(defaultVariants, override.defaultVariants),
+            compoundVariants: [
+                ...compoundVariants,
+                ...override.compoundVariants
+            ]
+        });
+    }
+    function cvaFn(props) {
+        return css_css(resolve(props));
+    }
+    const variantKeys = Object.keys(variants);
+    function splitVariantProps(props) {
+        return splitProps(props, variantKeys);
+    }
+    const variantMap = Object.fromEntries(Object.entries(variants).map((param)=>{
+        let [key, value] = param;
+        return [
+            key,
+            Object.keys(value)
+        ];
+    }));
+    return Object.assign(memo(cvaFn), {
+        __cva__: true,
+        variantMap,
+        variantKeys,
+        raw: resolve,
+        config,
+        merge,
+        splitVariantProps,
+        getVariantProps
+    });
+}
+function getCompoundVariantCss(compoundVariants, variantMap) {
+    let result = {};
+    compoundVariants.forEach((compoundVariant)=>{
+        const isMatching = Object.entries(compoundVariant).every((param)=>{
+            let [key, value] = param;
+            if (key === 'css') return true;
+            const values = Array.isArray(value) ? value : [
+                value
+            ];
+            return values.some((value)=>variantMap[key] === value);
+        });
+        if (isMatching) {
+            result = mergeCss(result, compoundVariant.css);
+        }
+    });
+    return result;
+}
+function assertCompoundVariant(name, compoundVariants, variants, prop) {
+    if (compoundVariants.length > 0 && typeof (variants == null ? void 0 : variants[prop]) === 'object') {
+        throw new Error("[recipe:" + name + ":" + prop + "] Conditions are not supported when using compound variants.");
+    }
+}
+
+var cva_assertCompoundVariant = /* unused export */ undefined;
+var cva_getCompoundVariantCss = /* unused export */ undefined;
+export { cva, cva_assertCompoundVariant as assertCompoundVariant, cva_getCompoundVariantCss as getCompoundVariantCss };

package/widget/multimodal_v2/styled-system/css/cx.js

@@ -0,0 +1,13 @@
+function cx() {
+    let str = '', i = 0, arg;
+    for(; i < arguments.length;){
+        if ((arg = arguments[i++]) && typeof arg === 'string') {
+            str && (str += ' ');
+            str += arg;
+        }
+    }
+    return str;
+}
+
+
+export { cx };

package/widget/multimodal_v2/styled-system/css/index.js

@@ -0,0 +1,15 @@
+import "./sva.js";
+
+
+
+
+
+
+var css_assertCompoundVariant = /* unused export */ undefined;
+var css_assignCss = /* unused export */ undefined;
+var css_getCompoundVariantCss = /* unused export */ undefined;
+var css_sva = /* unused export */ undefined;
+export { css_assertCompoundVariant as assertCompoundVariant, css_assignCss as assignCss, css_getCompoundVariantCss as getCompoundVariantCss, css_sva as sva };
+export { css, mergeCss } from "./css.js";
+export { cva } from "./cva.js";
+export { cx } from "./cx.js";

package/widget/multimodal_v2/styled-system/css/sva.js

@@ -0,0 +1,69 @@
+import "../helpers.js";
+import "./cva.js";
+
+
+
+
+
+function sva(config) {
+    var _config_defaultVariants, _config_variants;
+    const slots = Object.entries(getSlotRecipes(config)).map((param)=>{
+        let [slot, slotCva] = param;
+        return [
+            slot,
+            cva(slotCva)
+        ];
+    });
+    const defaultVariants = (_config_defaultVariants = config.defaultVariants) != null ? _config_defaultVariants : {};
+    const classNameMap = slots.reduce((acc, param)=>{
+        let [slot, cvaFn] = param;
+        if (config.className) acc[slot] = cvaFn.config.className;
+        return acc;
+    }, {});
+    function svaFn(props) {
+        const result = slots.map((param)=>{
+            let [slot, cvaFn] = param;
+            return [
+                slot,
+                cx(cvaFn(props), classNameMap[slot])
+            ];
+        });
+        return Object.fromEntries(result);
+    }
+    function raw(props) {
+        const result = slots.map((param)=>{
+            let [slot, cvaFn] = param;
+            return [
+                slot,
+                cvaFn.raw(props)
+            ];
+        });
+        return Object.fromEntries(result);
+    }
+    const variants = (_config_variants = config.variants) != null ? _config_variants : {};
+    const variantKeys = Object.keys(variants);
+    function splitVariantProps(props) {
+        return splitProps(props, variantKeys);
+    }
+    const getVariantProps = (variants)=>_extends({}, defaultVariants, compact(variants));
+    const variantMap = Object.fromEntries(Object.entries(variants).map((param)=>{
+        let [key, value] = param;
+        return [
+            key,
+            Object.keys(value)
+        ];
+    }));
+    return Object.assign(memo(svaFn), {
+        __cva__: false,
+        raw,
+        config,
+        variantMap,
+        variantKeys,
+        classNameMap,
+        splitVariantProps,
+        getVariantProps
+    });
+}
+
+var sva_sva = /* unused export */ undefined;
+export { sva_sva as sva };

package/widget/multimodal_v2/styled-system/helpers.js

@@ -0,0 +1,384 @@
+import { _object_without_properties_loose } from "../../../js/4101.js";
+
+
+
+// src/assert.ts
+function isObject(value) {
+    return typeof value === "object" && value != null && !Array.isArray(value);
+}
+var isObjectOrArray = (obj)=>typeof obj === "object" && obj !== null;
+// src/compact.ts
+function compact(value) {
+    return Object.fromEntries(Object.entries(value != null ? value : {}).filter((param)=>{
+        let [_, value2] = param;
+        return value2 !== void 0;
+    }));
+}
+// src/condition.ts
+var isBaseCondition = (v)=>v === "base";
+function filterBaseConditions(c) {
+    return c.slice().filter((v)=>!isBaseCondition(v));
+}
+// src/hash.ts
+function toChar(code) {
+    return String.fromCharCode(code + (code > 25 ? 39 : 97));
+}
+function toName(code) {
+    let name = "";
+    let x;
+    for(x = Math.abs(code); x > 52; x = x / 52 | 0)name = toChar(x % 52) + name;
+    return toChar(x % 52) + name;
+}
+function toPhash(h, x) {
+    let i = x.length;
+    while(i)h = h * 33 ^ x.charCodeAt(--i);
+    return h;
+}
+function toHash(value) {
+    return toName(toPhash(5381, value) >>> 0);
+}
+// src/important.ts
+var importantRegex = /\s*!(important)?/i;
+function isImportant(value) {
+    return typeof value === "string" ? importantRegex.test(value) : false;
+}
+function withoutImportant(value) {
+    return typeof value === "string" ? value.replace(importantRegex, "").trim() : value;
+}
+function withoutSpace(str) {
+    return typeof str === "string" ? str.replaceAll(" ", "_") : str;
+}
+// src/memo.ts
+var memo = (fn)=>{
+    const cache = /* @__PURE__ */ new Map();
+    const get = function get() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const key = JSON.stringify(args);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    };
+    return get;
+};
+// src/merge-props.ts
+var MERGE_OMIT = /* @__PURE__ */ new Set([
+    "__proto__",
+    "constructor",
+    "prototype"
+]);
+function mergeProps() {
+    for(var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++){
+        sources[_key] = arguments[_key];
+    }
+    return sources.reduce((prev, obj)=>{
+        if (!obj) return prev;
+        Object.keys(obj).forEach((key)=>{
+            if (MERGE_OMIT.has(key)) return;
+            const prevValue = prev[key];
+            const value = obj[key];
+            if (isObject(prevValue) && isObject(value)) {
+                prev[key] = mergeProps(prevValue, value);
+            } else {
+                prev[key] = value;
+            }
+        });
+        return prev;
+    }, {});
+}
+// src/walk-object.ts
+var isNotNullish = (element)=>element != null;
+function walkObject(target, predicate, options) {
+    if (options === void 0) options = {};
+    const { stop, getKey } = options;
+    function inner(value, path) {
+        if (path === void 0) path = [];
+        if (isObjectOrArray(value)) {
+            const result = {};
+            for (const [prop, child] of Object.entries(value)){
+                var _ref;
+                const key = (_ref = getKey == null ? void 0 : getKey(prop, child)) != null ? _ref : prop;
+                const childPath = [
+                    ...path,
+                    key
+                ];
+                if (stop == null ? void 0 : stop(value, childPath)) {
+                    return predicate(value, path);
+                }
+                const next = inner(child, childPath);
+                if (isNotNullish(next)) {
+                    result[key] = next;
+                }
+            }
+            return result;
+        }
+        return predicate(value, path);
+    }
+    return inner(target);
+}
+function mapObject(obj, fn) {
+    if (Array.isArray(obj)) return obj.map((value)=>fn(value));
+    if (!isObject(obj)) return fn(obj);
+    return walkObject(obj, (value)=>fn(value));
+}
+// src/normalize-style-object.ts
+function toResponsiveObject(values, breakpoints) {
+    return values.reduce((acc, current, index)=>{
+        const key = breakpoints[index];
+        if (current != null) {
+            acc[key] = current;
+        }
+        return acc;
+    }, {});
+}
+function normalizeStyleObject(styles, context, shorthand) {
+    if (shorthand === void 0) shorthand = true;
+    const { utility, conditions } = context;
+    const { hasShorthand, resolveShorthand } = utility;
+    return walkObject(styles, (value)=>{
+        return Array.isArray(value) ? toResponsiveObject(value, conditions.breakpoints.keys) : value;
+    }, {
+        stop: (value)=>Array.isArray(value),
+        getKey: shorthand ? (prop)=>hasShorthand ? resolveShorthand(prop) : prop : void 0
+    });
+}
+// src/classname.ts
+var fallbackCondition = {
+    shift: (v)=>v,
+    finalize: (v)=>v,
+    breakpoints: {
+        keys: []
+    }
+};
+var sanitize = (value)=>typeof value === "string" ? value.replaceAll(/[\n\s]+/g, " ") : value;
+function createCss(context) {
+    const { utility, hash, conditions: conds = fallbackCondition } = context;
+    const formatClassName = (str)=>[
+            utility.prefix,
+            str
+        ].filter(Boolean).join("-");
+    const hashFn = (conditions, className)=>{
+        let result;
+        if (hash) {
+            const baseArray = [
+                ...conds.finalize(conditions),
+                className
+            ];
+            result = formatClassName(utility.toHash(baseArray, toHash));
+        } else {
+            const baseArray = [
+                ...conds.finalize(conditions),
+                formatClassName(className)
+            ];
+            result = baseArray.join(":");
+        }
+        return result;
+    };
+    return memo((_0)=>{
+        if (_0 === void 0) _0 = void 0;
+        let _ref = [
+            _0
+        ], [_ref1 = {}] = _ref, { base } = _ref1, styles = _object_without_properties_loose(_ref1, [
+            "base"
+        ]);
+        const styleObject = Object.assign(styles, base);
+        const normalizedObject = normalizeStyleObject(styleObject, context);
+        const classNames = /* @__PURE__ */ new Set();
+        walkObject(normalizedObject, (value, paths)=>{
+            if (value == null) return;
+            const important = isImportant(value);
+            const [prop, ...allConditions] = conds.shift(paths);
+            const conditions = filterBaseConditions(allConditions);
+            const transformed = utility.transform(prop, withoutImportant(sanitize(value)));
+            let className = hashFn(conditions, transformed.className);
+            if (important) className = "" + className + "!";
+            classNames.add(className);
+        });
+        return Array.from(classNames).join(" ");
+    });
+}
+function compactStyles() {
+    for(var _len = arguments.length, styles = new Array(_len), _key = 0; _key < _len; _key++){
+        styles[_key] = arguments[_key];
+    }
+    return styles.flat().filter((style)=>isObject(style) && Object.keys(compact(style)).length > 0);
+}
+function createMergeCss(context) {
+    function resolve(styles) {
+        const allStyles = compactStyles(...styles);
+        if (allStyles.length === 1) return allStyles;
+        return allStyles.map((style)=>normalizeStyleObject(style, context));
+    }
+    function mergeCss() {
+        for(var _len = arguments.length, styles = new Array(_len), _key = 0; _key < _len; _key++){
+            styles[_key] = arguments[_key];
+        }
+        return mergeProps(...resolve(styles));
+    }
+    function assignCss() {
+        for(var _len = arguments.length, styles = new Array(_len), _key = 0; _key < _len; _key++){
+            styles[_key] = arguments[_key];
+        }
+        return Object.assign({}, ...resolve(styles));
+    }
+    return {
+        mergeCss: memo(mergeCss),
+        assignCss
+    };
+}
+// src/hypenate-property.ts
+var wordRegex = /([A-Z])/g;
+var msRegex = /^ms-/;
+var hypenateProperty = memo((property)=>{
+    if (property.startsWith("--")) return property;
+    return property.replace(wordRegex, "-$1").replace(msRegex, "-ms-").toLowerCase();
+});
+// src/is-css-function.ts
+var fns = [
+    "min",
+    "max",
+    "clamp",
+    "calc"
+];
+var fnRegExp = new RegExp("^(" + fns.join("|") + ")\\(.*\\)");
+var isCssFunction = (v)=>typeof v === "string" && fnRegExp.test(v);
+// src/is-css-unit.ts
+var lengthUnits = "cm,mm,Q,in,pc,pt,px,em,ex,ch,rem,lh,rlh,vw,vh,vmin,vmax,vb,vi,svw,svh,lvw,lvh,dvw,dvh,cqw,cqh,cqi,cqb,cqmin,cqmax,%";
+var lengthUnitsPattern = "(?:" + lengthUnits.split(",").join("|") + ")";
+var lengthRegExp = new RegExp("^[+-]?[0-9]*.?[0-9]+(?:[eE][+-]?[0-9]+)?" + lengthUnitsPattern + "$");
+var isCssUnit = (v)=>typeof v === "string" && lengthRegExp.test(v);
+// src/is-css-var.ts
+var isCssVar = (v)=>typeof v === "string" && /^var\(--.+\)$/.test(v);
+// src/pattern-fns.ts
+var patternFns = (/* unused pure expression or super */ null && ({
+    map: mapObject,
+    isCssFunction: isCssFunction,
+    isCssVar: isCssVar,
+    isCssUnit: isCssUnit
+}));
+var getPatternStyles = (pattern, styles)=>{
+    if (!(pattern == null ? void 0 : pattern.defaultValues)) return styles;
+    const defaults = typeof pattern.defaultValues === "function" ? pattern.defaultValues(styles) : pattern.defaultValues;
+    return Object.assign({}, defaults, compact(styles));
+};
+// src/slot.ts
+var getSlotRecipes = (recipe)=>{
+    if (recipe === void 0) recipe = {};
+    var _recipe_slots, _recipe_variants;
+    const init = (slot)=>{
+        var _ref, _recipe_defaultVariants;
+        var _recipe_base;
+        return {
+            className: [
+                recipe.className,
+                slot
+            ].filter(Boolean).join("__"),
+            base: (_ref = (_recipe_base = recipe.base) == null ? void 0 : _recipe_base[slot]) != null ? _ref : {},
+            variants: {},
+            defaultVariants: (_recipe_defaultVariants = recipe.defaultVariants) != null ? _recipe_defaultVariants : {},
+            compoundVariants: recipe.compoundVariants ? getSlotCompoundVariant(recipe.compoundVariants, slot) : []
+        };
+    };
+    const slots = (_recipe_slots = recipe.slots) != null ? _recipe_slots : [];
+    const recipeParts = slots.map((slot)=>[
+            slot,
+            init(slot)
+        ]);
+    for (const [variantsKey, variantsSpec] of Object.entries((_recipe_variants = recipe.variants) != null ? _recipe_variants : {})){
+        for (const [variantKey, variantSpec] of Object.entries(variantsSpec)){
+            recipeParts.forEach((param)=>{
+                let [slot, slotRecipe] = param;
+                var _slotRecipe_variants, _variantsKey, _, _variantSpec_slot;
+                (_ = (_slotRecipe_variants = slotRecipe.variants)[_variantsKey = variantsKey]) != null ? _ : _slotRecipe_variants[_variantsKey] = {};
+                slotRecipe.variants[variantsKey][variantKey] = (_variantSpec_slot = variantSpec[slot]) != null ? _variantSpec_slot : {};
+            });
+        }
+    }
+    return Object.fromEntries(recipeParts);
+};
+var getSlotCompoundVariant = (compoundVariants, slotName)=>compoundVariants.filter((compoundVariant)=>compoundVariant.css[slotName]).map((compoundVariant)=>_extends({}, compoundVariant, {
+            css: compoundVariant.css[slotName]
+        }));
+// src/split-props.ts
+function splitProps(props) {
+    for(var _len = arguments.length, keys = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+        keys[_key - 1] = arguments[_key];
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(props);
+    const dKeys = Object.keys(descriptors);
+    const split = (k)=>{
+        const clone = {};
+        for(let i = 0; i < k.length; i++){
+            const key = k[i];
+            if (descriptors[key]) {
+                Object.defineProperty(clone, key, descriptors[key]);
+                delete descriptors[key];
+            }
+        }
+        return clone;
+    };
+    const fn = (key)=>split(Array.isArray(key) ? key : dKeys.filter(key));
+    return keys.map(fn).concat(split(dKeys));
+}
+// src/uniq.ts
+var helpers_uniq = function uniq() {
+    for(var _len = arguments.length, items = new Array(_len), _key = 0; _key < _len; _key++){
+        items[_key] = arguments[_key];
+    }
+    const set = items.reduce((acc, currItems)=>{
+        if (currItems) {
+            currItems.forEach((item)=>acc.add(item));
+        }
+        return acc;
+    }, /* @__PURE__ */ new Set([]));
+    return Array.from(set);
+};
+
+// src/normalize-html.ts
+var htmlProps = [
+    "htmlSize",
+    "htmlTranslate",
+    "htmlWidth",
+    "htmlHeight"
+];
+function convert(key) {
+    return htmlProps.includes(key) ? key.replace("html", "").toLowerCase() : key;
+}
+function normalizeHTMLProps(props) {
+    return Object.fromEntries(Object.entries(props).map((param)=>{
+        let [key, value] = param;
+        return [
+            convert(key),
+            value
+        ];
+    }));
+}
+normalizeHTMLProps.keys = htmlProps;
+
+function __spreadValues(a, b) {
+    return _extends({}, a, b);
+}
+function __objRest(source, exclude) {
+    return Object.fromEntries(Object.entries(source).filter((param)=>{
+        let [key] = param;
+        return !exclude.includes(key);
+    }));
+}
+
+var helpers__objRest = /* unused export */ undefined;
+var helpers__spreadValues = /* unused export */ undefined;
+var helpers_filterBaseConditions = /* unused export */ undefined;
+var helpers_getPatternStyles = /* unused export */ undefined;
+var helpers_getSlotCompoundVariant = /* unused export */ undefined;
+var helpers_getSlotRecipes = /* unused export */ undefined;
+var helpers_isBaseCondition = /* unused export */ undefined;
+var helpers_isObject = /* unused export */ undefined;
+var helpers_mapObject = /* unused export */ undefined;
+var helpers_patternFns = /* unused export */ undefined;
+var helpers_toHash = /* unused export */ undefined;
+var helpers_walkObject = /* unused export */ undefined;
+export { compact, createCss, createMergeCss, helpers__objRest as __objRest, helpers__spreadValues as __spreadValues, helpers_filterBaseConditions as filterBaseConditions, helpers_getPatternStyles as getPatternStyles, helpers_getSlotCompoundVariant as getSlotCompoundVariant, helpers_getSlotRecipes as getSlotRecipes, helpers_isBaseCondition as isBaseCondition, helpers_isObject as isObject, helpers_mapObject as mapObject, helpers_patternFns as patternFns, helpers_toHash as toHash, helpers_uniq as uniq, helpers_walkObject as walkObject, hypenateProperty, memo, mergeProps, normalizeHTMLProps, splitProps, withoutSpace };