File Manager

Editing File: /home/ubuntu/voice-assistant-frontend/node_modules/styled-components/dist/styled-components.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react')) :
    typeof define === 'function' && define.amd ? define(['react'], factory) :
    (global = global || self, global.styled = factory(global.React));
})(this, (function (React) { 'use strict';

var SC_ATTR = (typeof process !== 'undefined' &&
        typeof process.env !== 'undefined' &&
        (process.env.REACT_APP_SC_ATTR || process.env.SC_ATTR)) ||
        'data-styled';
    var SC_ATTR_ACTIVE = 'active';
    var SC_ATTR_VERSION = 'data-styled-version';
    var SC_VERSION = "6.1.8";
    var SPLITTER = '/*!sc*/\n';
    var IS_BROWSER = typeof window !== 'undefined' && 'HTMLElement' in window;
    var DISABLE_SPEEDY = Boolean(typeof SC_DISABLE_SPEEDY === 'boolean'
        ? SC_DISABLE_SPEEDY
        : typeof process !== 'undefined' &&
            typeof process.env !== 'undefined' &&
            typeof process.env.REACT_APP_SC_DISABLE_SPEEDY !== 'undefined' &&
            process.env.REACT_APP_SC_DISABLE_SPEEDY !== ''
            ? process.env.REACT_APP_SC_DISABLE_SPEEDY === 'false'
                ? false
                : process.env.REACT_APP_SC_DISABLE_SPEEDY
            : typeof process !== 'undefined' &&
                typeof process.env !== 'undefined' &&
                typeof process.env.SC_DISABLE_SPEEDY !== 'undefined' &&
                process.env.SC_DISABLE_SPEEDY !== ''
                ? process.env.SC_DISABLE_SPEEDY === 'false'
                    ? false
                    : process.env.SC_DISABLE_SPEEDY
                : "development" !== 'production');
    // Shared empty execution context when generating static styles
    var STATIC_EXECUTION_CONTEXT = {};

/******************************************************************************
    Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
    purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
    PERFORMANCE OF THIS SOFTWARE.
    ***************************************************************************** */

var EMPTY_ARRAY = Object.freeze([]);
    var EMPTY_OBJECT = Object.freeze({});

/**
     * If the Object prototype is frozen, the "toString" property is non-writable. This means that any objects which inherit this property
     * cannot have the property changed using a "=" assignment operator. If using strict mode, attempting that will cause an error. If not using
     * strict mode, attempting that will be silently ignored.
     *
     * If the Object prototype is frozen, inherited non-writable properties can still be shadowed using one of two mechanisms:
     *
     *  1. ES6 class methods: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#methods
     *  2. Using the `Object.defineProperty()` static method:
     *     https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty
     *
     * However, this project uses Babel to transpile ES6 classes, and transforms ES6 class methods to use the assignment operator instead:
     * https://babeljs.io/docs/babel-plugin-transform-class-properties#options
     *
     * Therefore, the most compatible way to shadow the prototype's "toString" property is to define a new "toString" property on this object.
     */
    function setToString(object, toStringFn) {
        Object.defineProperty(object, 'toString', { value: toStringFn });
    }

/** Create a GroupedTag with an underlying Tag implementation */
    var makeGroupedTag = function (tag) {
        return new DefaultGroupedTag(tag);
    };
    var BASE_SIZE = 1 << 9;
    var DefaultGroupedTag = /** @class */ (function () {
        function DefaultGroupedTag(tag) {
            this.groupSizes = new Uint32Array(BASE_SIZE);
            this.length = BASE_SIZE;
            this.tag = tag;
        }
        DefaultGroupedTag.prototype.indexOfGroup = function (group) {
            var index = 0;
            for (var i = 0; i < group; i++) {
                index += this.groupSizes[i];
            }
            return index;
        };
        DefaultGroupedTag.prototype.insertRules = function (group, rules) {
            if (group >= this.groupSizes.length) {
                var oldBuffer = this.groupSizes;
                var oldSize = oldBuffer.length;
                var newSize = oldSize;
                while (group >= newSize) {
                    newSize <<= 1;
                    if (newSize < 0) {
                        throw throwStyledComponentsError(16, "".concat(group));
                    }
                }
                this.groupSizes = new Uint32Array(newSize);
                this.groupSizes.set(oldBuffer);
                this.length = newSize;
                for (var i = oldSize; i < newSize; i++) {
                    this.groupSizes[i] = 0;
                }
            }
            var ruleIndex = this.indexOfGroup(group + 1);
            for (var i = 0, l = rules.length; i < l; i++) {
                if (this.tag.insertRule(ruleIndex, rules[i])) {
                    this.groupSizes[group]++;
                    ruleIndex++;
                }
            }
        };
        DefaultGroupedTag.prototype.clearGroup = function (group) {
            if (group < this.length) {
                var length_1 = this.groupSizes[group];
                var startIndex = this.indexOfGroup(group);
                var endIndex = startIndex + length_1;
                this.groupSizes[group] = 0;
                for (var i = startIndex; i < endIndex; i++) {
                    this.tag.deleteRule(startIndex);
                }
            }
        };
        DefaultGroupedTag.prototype.getGroup = function (group) {
            var css = '';
            if (group >= this.length || this.groupSizes[group] === 0) {
                return css;
            }
            var length = this.groupSizes[group];
            var startIndex = this.indexOfGroup(group);
            var endIndex = startIndex + length;
            for (var i = startIndex; i < endIndex; i++) {
                css += "".concat(this.tag.getRule(i)).concat(SPLITTER);
            }
            return css;
        };
        return DefaultGroupedTag;
    }());

function getNonce() {
        return typeof __webpack_nonce__ !== 'undefined' ? __webpack_nonce__ : null;
    }

/** Find last style element if any inside target */
    var findLastStyleTag = function (target) {
        var arr = Array.from(target.querySelectorAll("style[".concat(SC_ATTR, "]")));
        return arr[arr.length - 1];
    };
    /** Create a style element inside `target` or <head> after the last */
    var makeStyleTag = function (target) {
        var head = document.head;
        var parent = target || head;
        var style = document.createElement('style');
        var prevStyle = findLastStyleTag(parent);
        var nextSibling = prevStyle !== undefined ? prevStyle.nextSibling : null;
        style.setAttribute(SC_ATTR, SC_ATTR_ACTIVE);
        style.setAttribute(SC_ATTR_VERSION, SC_VERSION);
        var nonce = getNonce();
        if (nonce)
            style.setAttribute('nonce', nonce);
        parent.insertBefore(style, nextSibling);
        return style;
    };
    /** Get the CSSStyleSheet instance for a given style element */
    var getSheet = function (tag) {
        if (tag.sheet) {
            return tag.sheet;
        }
        // Avoid Firefox quirk where the style element might not have a sheet property
        var styleSheets = document.styleSheets;
        for (var i = 0, l = styleSheets.length; i < l; i++) {
            var sheet = styleSheets[i];
            if (sheet.ownerNode === tag) {
                return sheet;
            }
        }
        throw throwStyledComponentsError(17);
    };

/** Create a CSSStyleSheet-like tag depending on the environment */
    var makeTag = function (_a) {
        var isServer = _a.isServer, useCSSOMInjection = _a.useCSSOMInjection, target = _a.target;
        if (isServer) {
            return new VirtualTag(target);
        }
        else if (useCSSOMInjection) {
            return new CSSOMTag(target);
        }
        else {
            return new TextTag(target);
        }
    };
    var CSSOMTag = /** @class */ (function () {
        function CSSOMTag(target) {
            this.element = makeStyleTag(target);
            // Avoid Edge bug where empty style elements don't create sheets
            this.element.appendChild(document.createTextNode(''));
            this.sheet = getSheet(this.element);
            this.length = 0;
        }
        CSSOMTag.prototype.insertRule = function (index, rule) {
            try {
                this.sheet.insertRule(rule, index);
                this.length++;
                return true;
            }
            catch (_error) {
                return false;
            }
        };
        CSSOMTag.prototype.deleteRule = function (index) {
            this.sheet.deleteRule(index);
            this.length--;
        };
        CSSOMTag.prototype.getRule = function (index) {
            var rule = this.sheet.cssRules[index];
            // Avoid IE11 quirk where cssText is inaccessible on some invalid rules
            if (rule && rule.cssText) {
                return rule.cssText;
            }
            else {
                return '';
            }
        };
        return CSSOMTag;
    }());
    /** A Tag that emulates the CSSStyleSheet API but uses text nodes */
    var TextTag = /** @class */ (function () {
        function TextTag(target) {
            this.element = makeStyleTag(target);
            this.nodes = this.element.childNodes;
            this.length = 0;
        }
        TextTag.prototype.insertRule = function (index, rule) {
            if (index <= this.length && index >= 0) {
                var node = document.createTextNode(rule);
                var refNode = this.nodes[index];
                this.element.insertBefore(node, refNode || null);
                this.length++;
                return true;
            }
            else {
                return false;
            }
        };
        TextTag.prototype.deleteRule = function (index) {
            this.element.removeChild(this.nodes[index]);
            this.length--;
        };
        TextTag.prototype.getRule = function (index) {
            if (index < this.length) {
                return this.nodes[index].textContent;
            }
            else {
                return '';
            }
        };
        return TextTag;
    }());
    /** A completely virtual (server-side) Tag that doesn't manipulate the DOM */
    var VirtualTag = /** @class */ (function () {
        function VirtualTag(_target) {
            this.rules = [];
            this.length = 0;
        }
        VirtualTag.prototype.insertRule = function (index, rule) {
            if (index <= this.length) {
                this.rules.splice(index, 0, rule);
                this.length++;
                return true;
            }
            else {
                return false;
            }
        };
        VirtualTag.prototype.deleteRule = function (index) {
            this.rules.splice(index, 1);
            this.length--;
        };
        VirtualTag.prototype.getRule = function (index) {
            if (index < this.length) {
                return this.rules[index];
            }
            else {
                return '';
            }
        };
        return VirtualTag;
    }());

var shallowequal = function shallowEqual(objA, objB, compare, compareContext) {
      var ret = compare ? compare.call(compareContext, objA, objB) : void 0;

if (ret !== void 0) {
        return !!ret;
      }

if (objA === objB) {
        return true;
      }

if (typeof objA !== "object" || !objA || typeof objB !== "object" || !objB) {
        return false;
      }

var keysA = Object.keys(objA);
      var keysB = Object.keys(objB);

if (keysA.length !== keysB.length) {
        return false;
      }

var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);

// Test for A's keys different from B.
      for (var idx = 0; idx < keysA.length; idx++) {
        var key = keysA[idx];

if (!bHasOwnProperty(key)) {
          return false;
        }

var valueA = objA[key];
        var valueB = objB[key];

ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;

if (ret === false || (ret === void 0 && valueA !== valueB)) {
          return false;
        }
      }

return true;
    };

var unitlessKeys = {
      animationIterationCount: 1,
      borderImageOutset: 1,
      borderImageSlice: 1,
      borderImageWidth: 1,
      boxFlex: 1,
      boxFlexGroup: 1,
      boxOrdinalGroup: 1,
      columnCount: 1,
      columns: 1,
      flex: 1,
      flexGrow: 1,
      flexPositive: 1,
      flexShrink: 1,
      flexNegative: 1,
      flexOrder: 1,
      gridRow: 1,
      gridRowEnd: 1,
      gridRowSpan: 1,
      gridRowStart: 1,
      gridColumn: 1,
      gridColumnEnd: 1,
      gridColumnSpan: 1,
      gridColumnStart: 1,
      msGridRow: 1,
      msGridRowSpan: 1,
      msGridColumn: 1,
      msGridColumnSpan: 1,
      fontWeight: 1,
      lineHeight: 1,
      opacity: 1,
      order: 1,
      orphans: 1,
      tabSize: 1,
      widows: 1,
      zIndex: 1,
      zoom: 1,
      WebkitLineClamp: 1,
      // SVG-related properties
      fillOpacity: 1,
      floodOpacity: 1,
      stopOpacity: 1,
      strokeDasharray: 1,
      strokeDashoffset: 1,
      strokeMiterlimit: 1,
      strokeOpacity: 1,
      strokeWidth: 1
    };

// Taken from https://github.com/facebook/react/blob/b87aabdfe1b7461e7331abb3601d9e6bb27544bc/packages/react-dom/src/shared/dangerousStyleValue.js
    function addUnitIfNeeded(name, value) {
        // https://github.com/amilajack/eslint-plugin-flowtype-errors/issues/133
        if (value == null || typeof value === 'boolean' || value === '') {
            return '';
        }
        if (typeof value === 'number' && value !== 0 && !(name in unitlessKeys) && !name.startsWith('--')) {
            return "".concat(value, "px"); // Presumes implicit 'px' suffix for unitless numbers except for CSS variables
        }
        return String(value).trim();
    }

function getComponentName(target) {
        return ((typeof target === 'string' && target ) ||
            target.displayName ||
            target.name ||
            'Component');
    }

function isFunction(test) {
        return typeof test === 'function';
    }

function isPlainObject(x) {
        return (x !== null &&
            typeof x === 'object' &&
            x.constructor.name === Object.name &&
            /* check for reasonable markers that the object isn't an element for react & preact/compat */
            !('props' in x && x.$$typeof));
    }

function isStatelessFunction(test) {
        return isFunction(test) && !(test.prototype && test.prototype.isReactComponent);
    }

function isStyledComponent(target) {
        return typeof target === 'object' && 'styledComponentId' in target;
    }

/**
     * It's falsish not falsy because 0 is allowed.
     */
    var isFalsish = function (chunk) {
        return chunk === undefined || chunk === null || chunk === false || chunk === '';
    };
    var objToCssArray = function (obj) {
        var rules = [];
        for (var key in obj) {
            var val = obj[key];
            if (!obj.hasOwnProperty(key) || isFalsish(val))
                continue;
            // @ts-expect-error Property 'isCss' does not exist on type 'any[]'
            if ((Array.isArray(val) && val.isCss) || isFunction(val)) {
                rules.push("".concat(hyphenateStyleName(key), ":"), val, ';');
            }
            else if (isPlainObject(val)) {
                rules.push.apply(rules, __spreadArray(__spreadArray(["".concat(key, " {")], objToCssArray(val), false), ['}'], false));
            }
            else {
                rules.push("".concat(hyphenateStyleName(key), ": ").concat(addUnitIfNeeded(key, val), ";"));
            }
        }
        return rules;
    };
    function flatten(chunk, executionContext, styleSheet, stylisInstance) {
        if (isFalsish(chunk)) {
            return [];
        }
        /* Handle other components */
        if (isStyledComponent(chunk)) {
            return [".".concat(chunk.styledComponentId)];
        }
        /* Either execute or defer the function */
        if (isFunction(chunk)) {
            if (isStatelessFunction(chunk) && executionContext) {
                var result = chunk(executionContext);
                if (typeof result === 'object' &&
                    !Array.isArray(result) &&
                    !(result instanceof Keyframes) &&
                    !isPlainObject(result) &&
                    result !== null) {
                    console.error("".concat(getComponentName(chunk), " is not a styled component and cannot be referred to via component selector. See https://www.styled-components.com/docs/advanced#referring-to-other-components for more details."));
                }
                return flatten(result, executionContext, styleSheet, stylisInstance);
            }
            else {
                return [chunk];
            }
        }
        if (chunk instanceof Keyframes) {
            if (styleSheet) {
                chunk.inject(styleSheet, stylisInstance);
                return [chunk.getName(stylisInstance)];
            }
            else {
                return [chunk];
            }
        }
        /* Handle objects */
        if (isPlainObject(chunk)) {
            return objToCssArray(chunk);
        }
        if (!Array.isArray(chunk)) {
            return [chunk.toString()];
        }
        return flatMap(chunk, function (chunklet) {
            return flatten(chunklet, executionContext, styleSheet, stylisInstance);
        });
    }
    function flatMap(array, transform) {
        return Array.prototype.concat.apply(EMPTY_ARRAY, array.map(transform));
    }

/**
     * Convenience function for joining strings to form className chains
     */
    function joinStrings(a, b) {
        return a && b ? "".concat(a, " ").concat(b) : a || b || '';
    }
    function joinStringArray(arr, sep) {
        if (arr.length === 0) {
            return '';
        }
        var result = arr[0];
        for (var i = 1; i < arr.length; i++) {
            result += sep ? sep + arr[i] : arr[i];
        }
        return result;
    }

function determineTheme(props, providedTheme, defaultProps) {
        if (defaultProps === void 0) { defaultProps = EMPTY_OBJECT; }
        return (props.theme !== defaultProps.theme && props.theme) || providedTheme || defaultProps.theme;
    }

function generateComponentId(str) {
        return generateAlphabeticName(hash(str) >>> 0);
    }

function interleave(strings, interpolations) {
        var result = [strings[0]];
        for (var i = 0, len = interpolations.length; i < len; i += 1) {
            result.push(interpolations[i], strings[i + 1]);
        }
        return result;
    }

/**
     * Used when flattening object styles to determine if we should
     * expand an array of styles.
     */
    var addTag = function (arg) {
        return Object.assign(arg, { isCss: true });
    };
    function css(styles) {
        var interpolations = [];
        for (var _i = 1; _i < arguments.length; _i++) {
            interpolations[_i - 1] = arguments[_i];
        }
        if (isFunction(styles) || isPlainObject(styles)) {
            var styleFunctionOrObject = styles;
            return addTag(flatten(interleave(EMPTY_ARRAY, __spreadArray([
                styleFunctionOrObject
            ], interpolations, true))));
        }
        var styleStringArray = styles;
        if (interpolations.length === 0 &&
            styleStringArray.length === 1 &&
            typeof styleStringArray[0] === 'string') {
            return flatten(styleStringArray);
        }
        return addTag(flatten(interleave(styleStringArray, interpolations)));
    }

var _a;
    var hasSymbol = typeof Symbol === 'function' && Symbol.for;
    // copied from react-is
    var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
    var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
    /**
     * Adapted from hoist-non-react-statics to avoid the react-is dependency.
     */
    var REACT_STATICS = {
        childContextTypes: true,
        contextType: true,
        contextTypes: true,
        defaultProps: true,
        displayName: true,
        getDefaultProps: true,
        getDerivedStateFromError: true,
        getDerivedStateFromProps: true,
        mixins: true,
        propTypes: true,
        type: true,
    };
    var KNOWN_STATICS = {
        name: true,
        length: true,
        prototype: true,
        caller: true,
        callee: true,
        arguments: true,
        arity: true,
    };
    var FORWARD_REF_STATICS = {
        $$typeof: true,
        render: true,
        defaultProps: true,
        displayName: true,
        propTypes: true,
    };
    var MEMO_STATICS = {
        $$typeof: true,
        compare: true,
        defaultProps: true,
        displayName: true,
        propTypes: true,
        type: true,
    };
    var TYPE_STATICS = (_a = {},
        _a[REACT_FORWARD_REF_TYPE] = FORWARD_REF_STATICS,
        _a[REACT_MEMO_TYPE] = MEMO_STATICS,
        _a);
    // adapted from react-is
    function isMemo(object) {
        var $$typeofType = 'type' in object && object.type.$$typeof;
        return $$typeofType === REACT_MEMO_TYPE;
    }
    function getStatics(component) {
        // React v16.11 and below
        if (isMemo(component)) {
            return MEMO_STATICS;
        }
        // React v16.12 and above
        return '$$typeof' in component
            ? TYPE_STATICS[component['$$typeof']]
            : REACT_STATICS;
    }
    var defineProperty = Object.defineProperty;
    var getOwnPropertyNames = Object.getOwnPropertyNames;
    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
    var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
    var getPrototypeOf = Object.getPrototypeOf;
    var objectPrototype = Object.prototype;
    function hoistNonReactStatics(targetComponent, sourceComponent, excludelist) {
        if (typeof sourceComponent !== 'string') {
            // don't hoist over string (html) components
            if (objectPrototype) {
                var inheritedComponent = getPrototypeOf(sourceComponent);
                if (inheritedComponent && inheritedComponent !== objectPrototype) {
                    hoistNonReactStatics(targetComponent, inheritedComponent, excludelist);
                }
            }
            var keys = getOwnPropertyNames(sourceComponent);
            if (getOwnPropertySymbols) {
                keys = keys.concat(getOwnPropertySymbols(sourceComponent));
            }
            var targetStatics = getStatics(targetComponent);
            var sourceStatics = getStatics(sourceComponent);
            for (var i = 0; i < keys.length; ++i) {
                var key = keys[i];
                if (!(key in KNOWN_STATICS) &&
                    !(excludelist && excludelist[key]) &&
                    !(sourceStatics && key in sourceStatics) &&
                    !(targetStatics && key in targetStatics)) {
                    var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
                    try {
                        // Avoid failures from read-only properties
                        defineProperty(targetComponent, key, descriptor);
                    }
                    catch (e) {
                        /* ignore */
                    }
                }
            }
        }
        return targetComponent;
    }

var __PRIVATE__ = {
        StyleSheet: StyleSheet,
        mainSheet: mainSheet,
    };

/* Import singletons */
    /* Warning if you've imported this file on React Native */
    if (typeof navigator !== 'undefined' &&
        navigator.product === 'ReactNative') {
        console.warn("It looks like you've imported 'styled-components' on React Native.\nPerhaps you're looking to import 'styled-components/native'?\nRead more about this at https://www.styled-components.com/docs/basics#react-native");
    }
    var windowGlobalKey = "__sc-".concat(SC_ATTR, "__");
    /* Warning if there are several instances of styled-components */
    if (typeof window !== 'undefined') {
        // @ts-expect-error dynamic key not in window object
        window[windowGlobalKey] || (window[windowGlobalKey] = 0);
        // @ts-expect-error dynamic key not in window object
        if (window[windowGlobalKey] === 1) {
            console.warn("It looks like there are several instances of 'styled-components' initialized in this application. This may cause dynamic styles to not render properly, errors during the rehydration process, a missing theme prop, and makes your application bigger without good reason.\n\nSee https://s-c.sh/2BAXzed for more info.");
        }
        // @ts-expect-error dynamic key not in window object
        window[windowGlobalKey] += 1;
    }

var secondary = /*#__PURE__*/Object.freeze({
        __proto__: null,
        ServerStyleSheet: ServerStyleSheet,
        StyleSheetConsumer: StyleSheetConsumer,
        StyleSheetContext: StyleSheetContext,
        StyleSheetManager: StyleSheetManager,
        ThemeConsumer: ThemeConsumer,
        ThemeContext: ThemeContext,
        ThemeProvider: ThemeProvider,
        __PRIVATE__: __PRIVATE__,
        createGlobalStyle: createGlobalStyle,
        css: css,
        isStyledComponent: isStyledComponent,
        keyframes: keyframes,
        useTheme: useTheme,
        version: SC_VERSION,
        withTheme: withTheme
    });

function memoize(fn) {
      var cache = Object.create(null);
      return function (arg) {
        if (cache[arg] === undefined) cache[arg] = fn(arg);
        return cache[arg];
      };
    }

var isPropValid = /* #__PURE__ */memoize(function (prop) {
      return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111
      /* o */
      && prop.charCodeAt(1) === 110
      /* n */
      && prop.charCodeAt(2) < 91;
    }
    /* Z+1 */
    );

// Thanks to ReactDOMFactories for this handy list!
    var elements = [
        'a',
        'abbr',
        'address',
        'area',
        'article',
        'aside',
        'audio',
        'b',
        'base',
        'bdi',
        'bdo',
        'big',
        'blockquote',
        'body',
        'br',
        'button',
        'canvas',
        'caption',
        'cite',
        'code',
        'col',
        'colgroup',
        'data',
        'datalist',
        'dd',
        'del',
        'details',
        'dfn',
        'dialog',
        'div',
        'dl',
        'dt',
        'em',
        'embed',
        'fieldset',
        'figcaption',
        'figure',
        'footer',
        'form',
        'h1',
        'h2',
        'h3',
        'h4',
        'h5',
        'h6',
        'header',
        'hgroup',
        'hr',
        'html',
        'i',
        'iframe',
        'img',
        'input',
        'ins',
        'kbd',
        'keygen',
        'label',
        'legend',
        'li',
        'link',
        'main',
        'map',
        'mark',
        'menu',
        'menuitem',
        'meta',
        'meter',
        'nav',
        'noscript',
        'object',
        'ol',
        'optgroup',
        'option',
        'output',
        'p',
        'param',
        'picture',
        'pre',
        'progress',
        'q',
        'rp',
        'rt',
        'ruby',
        's',
        'samp',
        'script',
        'section',
        'select',
        'small',
        'source',
        'span',
        'strong',
        'style',
        'sub',
        'summary',
        'sup',
        'table',
        'tbody',
        'td',
        'textarea',
        'tfoot',
        'th',
        'thead',
        'time',
        'tr',
        'track',
        'u',
        'ul',
        'use',
        'var',
        'video',
        'wbr',
        'circle',
        'clipPath',
        'defs',
        'ellipse',
        'foreignObject',
        'g',
        'image',
        'line',
        'linearGradient',
        'marker',
        'mask',
        'path',
        'pattern',
        'polygon',
        'polyline',
        'radialGradient',
        'rect',
        'stop',
        'svg',
        'text',
        'tspan',
    ];
    var domElements = new Set(elements);

// Source: https://www.w3.org/TR/cssom-1/#serialize-an-identifier
    // Control characters and non-letter first symbols are not supported
    var escapeRegex = /[!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~-]+/g;
    var dashesAtEnds = /(^-|-$)/g;
    /**
     * TODO: Explore using CSS.escape when it becomes more available
     * in evergreen browsers.
     */
    function escape(str) {
        return str // Replace all possible CSS selectors
            .replace(escapeRegex, '-') // Remove extraneous hyphens at the start and end
            .replace(dashesAtEnds, '');
    }

function isTag(target) {
        return (typeof target === 'string' &&
            (target.charAt(0) === target.charAt(0).toLowerCase()
                ));
    }

function generateDisplayName(target) {
        return isTag(target) ? "styled.".concat(target) : "Styled(".concat(getComponentName(target), ")");
    }

var baseStyled = function (tag) {
        return constructWithOptions(createStyledComponent, tag);
    };
    var styled = baseStyled;
    // Shorthands for all valid HTML Elements
    domElements.forEach(function (domElement) {
        // @ts-expect-error some react typing bs
        styled[domElement] = baseStyled(domElement);
    });

/**
     * eliminates the need to do styled.default since the other APIs
     * are directly assigned as properties to the main function
     * */
    for (var key in secondary) {
        // @ts-expect-error shush
        styled[key] = secondary[key];
    }

return styled;

}));
//# sourceMappingURL=styled-components.js.map

Back to Directory File Manager