@dotss/ui 0.0.4

package/node_modules/@emotion/serialize/src/index.ts

@@ -0,0 +1,451 @@
+import type { RegisteredCache, SerializedStyles } from '@emotion/utils'
+import hashString from '@emotion/hash'
+import unitless from '@emotion/unitless'
+import memoize from '@emotion/memoize'
+import isDevelopment from '#is-development'
+import * as CSS from 'csstype'
+
+export type { RegisteredCache, SerializedStyles }
+
+type Cursor = {
+  name: string
+  styles: string
+  next?: Cursor
+}
+
+export type CSSProperties = CSS.PropertiesFallback<number | string>
+export type CSSPropertiesWithMultiValues = {
+  [K in keyof CSSProperties]:
+    | CSSProperties[K]
+    | ReadonlyArray<Extract<CSSProperties[K], string>>
+}
+
+export type CSSPseudos = { [K in CSS.Pseudos]?: CSSObject }
+
+export interface ArrayCSSInterpolation
+  extends ReadonlyArray<CSSInterpolation> {}
+
+export type InterpolationPrimitive =
+  | null
+  | undefined
+  | boolean
+  | number
+  | string
+  | ComponentSelector
+  | Keyframes
+  | SerializedStyles
+  | CSSObject
+
+export type CSSInterpolation = InterpolationPrimitive | ArrayCSSInterpolation
+
+export interface CSSOthersObject {
+  [propertiesName: string]: CSSInterpolation
+}
+
+export interface CSSObject
+  extends CSSPropertiesWithMultiValues,
+    CSSPseudos,
+    CSSOthersObject {}
+
+export interface ComponentSelector {
+  __emotion_styles: any
+}
+
+export type Keyframes = {
+  name: string
+  styles: string
+  anim: number
+  toString: () => string
+} & string
+
+export interface ArrayInterpolation<Props = unknown>
+  extends ReadonlyArray<Interpolation<Props>> {}
+
+export interface FunctionInterpolation<Props = unknown> {
+  (props: Props): Interpolation<Props>
+}
+
+export type Interpolation<Props = unknown> =
+  | InterpolationPrimitive
+  | ArrayInterpolation<Props>
+  | FunctionInterpolation<Props>
+
+const ILLEGAL_ESCAPE_SEQUENCE_ERROR = `You have illegal escape sequence in your template literal, most likely inside content's property value.
+Because you write your CSS inside a JavaScript string you actually have to do double escaping, so for example "content: '\\00d7';" should become "content: '\\\\00d7';".
+You can read more about this here:
+https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences`
+
+const UNDEFINED_AS_OBJECT_KEY_ERROR =
+  "You have passed in falsy value as style object's key (can happen when in example you pass unexported component as computed key)."
+
+let hyphenateRegex = /[A-Z]|^ms/g
+let animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g
+
+const isCustomProperty = (property: string) => property.charCodeAt(1) === 45
+const isProcessableValue = (value: Interpolation) =>
+  value != null && typeof value !== 'boolean'
+
+const processStyleName = /* #__PURE__ */ memoize((styleName: string) =>
+  isCustomProperty(styleName)
+    ? styleName
+    : styleName.replace(hyphenateRegex, '-$&').toLowerCase()
+)
+
+let processStyleValue = (
+  key: string,
+  value: string | number
+): string | number => {
+  switch (key) {
+    case 'animation':
+    case 'animationName': {
+      if (typeof value === 'string') {
+        return value.replace(animationRegex, (match, p1, p2) => {
+          cursor = {
+            name: p1,
+            styles: p2,
+            next: cursor
+          }
+          return p1
+        })
+      }
+    }
+  }
+
+  if (
+    unitless[key as keyof typeof unitless] !== 1 &&
+    !isCustomProperty(key) &&
+    typeof value === 'number' &&
+    value !== 0
+  ) {
+    return value + 'px'
+  }
+  return value
+}
+
+if (isDevelopment) {
+  let contentValuePattern =
+    /(var|attr|counters?|url|element|(((repeating-)?(linear|radial))|conic)-gradient)\(|(no-)?(open|close)-quote/
+  let contentValues = ['normal', 'none', 'initial', 'inherit', 'unset']
+
+  let oldProcessStyleValue = processStyleValue
+
+  let msPattern = /^-ms-/
+  let hyphenPattern = /-(.)/g
+
+  let hyphenatedCache: Record<string, boolean | undefined> = {}
+
+  processStyleValue = (key: string, value: string | number) => {
+    if (key === 'content') {
+      if (
+        typeof value !== 'string' ||
+        (contentValues.indexOf(value) === -1 &&
+          !contentValuePattern.test(value) &&
+          (value.charAt(0) !== value.charAt(value.length - 1) ||
+            (value.charAt(0) !== '"' && value.charAt(0) !== "'")))
+      ) {
+        throw new Error(
+          `You seem to be using a value for 'content' without quotes, try replacing it with \`content: '"${value}"'\``
+        )
+      }
+    }
+
+    const processed = oldProcessStyleValue(key, value)
+
+    if (
+      processed !== '' &&
+      !isCustomProperty(key) &&
+      key.indexOf('-') !== -1 &&
+      hyphenatedCache[key] === undefined
+    ) {
+      hyphenatedCache[key] = true
+      console.error(
+        `Using kebab-case for css properties in objects is not supported. Did you mean ${key
+          .replace(msPattern, 'ms-')
+          .replace(hyphenPattern, (str, char) => char.toUpperCase())}?`
+      )
+    }
+
+    return processed
+  }
+}
+
+const noComponentSelectorMessage =
+  'Component selectors can only be used in conjunction with ' +
+  '@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware ' +
+  'compiler transform.'
+
+function handleInterpolation(
+  mergedProps: unknown | undefined,
+  registered: RegisteredCache | undefined,
+  interpolation: Interpolation
+): string | number {
+  if (interpolation == null) {
+    return ''
+  }
+  const componentSelector = interpolation as ComponentSelector
+  if (componentSelector.__emotion_styles !== undefined) {
+    if (
+      isDevelopment &&
+      String(componentSelector) === 'NO_COMPONENT_SELECTOR'
+    ) {
+      throw new Error(noComponentSelectorMessage)
+    }
+    return componentSelector as unknown as string
+  }
+
+  switch (typeof interpolation) {
+    case 'boolean': {
+      return ''
+    }
+    case 'object': {
+      const keyframes = interpolation as Keyframes
+      if (keyframes.anim === 1) {
+        cursor = {
+          name: keyframes.name,
+          styles: keyframes.styles,
+          next: cursor
+        }
+
+        return keyframes.name
+      }
+      const serializedStyles = interpolation as SerializedStyles
+      if (serializedStyles.styles !== undefined) {
+        let next = serializedStyles.next
+        if (next !== undefined) {
+          // not the most efficient thing ever but this is a pretty rare case
+          // and there will be very few iterations of this generally
+          while (next !== undefined) {
+            cursor = {
+              name: next.name,
+              styles: next.styles,
+              next: cursor
+            }
+            next = next.next
+          }
+        }
+        let styles = `${serializedStyles.styles};`
+        return styles
+      }
+
+      return createStringFromObject(
+        mergedProps,
+        registered,
+        interpolation as ArrayInterpolation | CSSObject
+      )
+    }
+    case 'function': {
+      if (mergedProps !== undefined) {
+        let previousCursor = cursor
+        let result = interpolation(mergedProps)
+        cursor = previousCursor
+
+        return handleInterpolation(mergedProps, registered, result)
+      } else if (isDevelopment) {
+        console.error(
+          'Functions that are interpolated in css calls will be stringified.\n' +
+            'If you want to have a css call based on props, create a function that returns a css call like this\n' +
+            'let dynamicStyle = (props) => css`color: ${props.color}`\n' +
+            'It can be called directly with props or interpolated in a styled call like this\n' +
+            "let SomeComponent = styled('div')`${dynamicStyle}`"
+        )
+      }
+      break
+    }
+    case 'string':
+      if (isDevelopment) {
+        const matched: string[] = []
+        const replaced = interpolation.replace(
+          animationRegex,
+          (_match, _p1, p2) => {
+            const fakeVarName = `animation${matched.length}`
+            matched.push(
+              `const ${fakeVarName} = keyframes\`${p2.replace(
+                /^@keyframes animation-\w+/,
+                ''
+              )}\``
+            )
+            return `\${${fakeVarName}}`
+          }
+        )
+        if (matched.length) {
+          console.error(
+            `\`keyframes\` output got interpolated into plain string, please wrap it with \`css\`.
+
+Instead of doing this:
+
+${[...matched, `\`${replaced}\``].join('\n')}
+
+You should wrap it with \`css\` like this:
+
+css\`${replaced}\``
+          )
+        }
+      }
+      break
+  }
+
+  // finalize string values (regular strings and functions interpolated into css calls)
+  const asString = interpolation as string
+  if (registered == null) {
+    return asString
+  }
+  const cached = registered[asString]
+  return cached !== undefined ? cached : asString
+}
+
+function createStringFromObject(
+  mergedProps: unknown | undefined,
+  registered: RegisteredCache | undefined,
+  obj: ArrayInterpolation | CSSObject
+): string {
+  let string = ''
+
+  if (Array.isArray(obj)) {
+    for (let i = 0; i < obj.length; i++) {
+      string += `${handleInterpolation(mergedProps, registered, obj[i])};`
+    }
+  } else {
+    for (let key in obj) {
+      let value: unknown = obj[key as never]
+      if (typeof value !== 'object') {
+        const asString = value as string
+        if (registered != null && registered[asString] !== undefined) {
+          string += `${key}{${registered[asString]}}`
+        } else if (isProcessableValue(asString)) {
+          string += `${processStyleName(key)}:${processStyleValue(
+            key,
+            asString
+          )};`
+        }
+      } else {
+        if (key === 'NO_COMPONENT_SELECTOR' && isDevelopment) {
+          throw new Error(noComponentSelectorMessage)
+        }
+        if (
+          Array.isArray(value) &&
+          typeof value[0] === 'string' &&
+          (registered == null || registered[value[0]] === undefined)
+        ) {
+          for (let i = 0; i < value.length; i++) {
+            if (isProcessableValue(value[i])) {
+              string += `${processStyleName(key)}:${processStyleValue(
+                key,
+                value[i] as string | number
+              )};`
+            }
+          }
+        } else {
+          const interpolated = handleInterpolation(
+            mergedProps,
+            registered,
+            value as Interpolation
+          )
+          switch (key) {
+            case 'animation':
+            case 'animationName': {
+              string += `${processStyleName(key)}:${interpolated};`
+              break
+            }
+            default: {
+              if (isDevelopment && key === 'undefined') {
+                console.error(UNDEFINED_AS_OBJECT_KEY_ERROR)
+              }
+              string += `${key}{${interpolated}}`
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return string
+}
+
+let labelPattern = /label:\s*([^\s;{]+)\s*(;|$)/g
+
+// this is the cursor for keyframes
+// keyframes are stored on the SerializedStyles object as a linked list
+let cursor: Cursor | undefined
+
+export function serializeStyles<Props>(
+  args: Array<TemplateStringsArray | Interpolation<Props>>,
+  registered?: RegisteredCache,
+  mergedProps?: Props
+): SerializedStyles
+export function serializeStyles(
+  args: Array<TemplateStringsArray | Interpolation<unknown>>,
+  registered?: RegisteredCache,
+  mergedProps?: unknown
+): SerializedStyles {
+  if (
+    args.length === 1 &&
+    typeof args[0] === 'object' &&
+    args[0] !== null &&
+    (args[0] as SerializedStyles).styles !== undefined
+  ) {
+    return args[0] as SerializedStyles
+  }
+  let stringMode = true
+  let styles = ''
+
+  cursor = undefined
+  let strings = args[0]
+  if (strings == null || (strings as TemplateStringsArray).raw === undefined) {
+    stringMode = false
+    styles += handleInterpolation(
+      mergedProps,
+      registered,
+      strings as Interpolation
+    )
+  } else {
+    const asTemplateStringsArr = strings as TemplateStringsArray
+    if (isDevelopment && asTemplateStringsArr[0] === undefined) {
+      console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR)
+    }
+    styles += asTemplateStringsArr[0]
+  }
+  // we start at 1 since we've already handled the first arg
+  for (let i = 1; i < args.length; i++) {
+    styles += handleInterpolation(
+      mergedProps,
+      registered,
+      args[i] as Interpolation
+    )
+    if (stringMode) {
+      const templateStringsArr = strings as TemplateStringsArray
+      if (isDevelopment && templateStringsArr[i] === undefined) {
+        console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR)
+      }
+      styles += templateStringsArr[i]
+    }
+  }
+
+  // using a global regex with .exec is stateful so lastIndex has to be reset each time
+  labelPattern.lastIndex = 0
+  let identifierName = ''
+
+  let match
+  // https://esbench.com/bench/5b809c2cf2949800a0f61fb5
+  while ((match = labelPattern.exec(styles)) !== null) {
+    identifierName += '-' + match[1]
+  }
+
+  let name = hashString(styles) + identifierName
+
+  if (isDevelopment) {
+    const devStyles = {
+      name,
+      styles,
+      next: cursor,
+      toString() {
+        return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."
+      }
+    }
+    return devStyles
+  }
+  return {
+    name,
+    styles,
+    next: cursor
+  }
+}

package/node_modules/@emotion/styled/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Emotion team and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@emotion/styled/README.md

@@ -0,0 +1,31 @@
+# @emotion/styled
+
+> The styled API for @emotion/react
+
+## Install
+
+```bash
+yarn add @emotion/react @emotion/styled
+```
+
+## Usage
+
+```jsx
+import styled from '@emotion/styled'
+
+let SomeComp = styled.div({
+  color: 'hotpink'
+})
+
+let AnotherComp = styled.div`
+  color: ${props => props.color};
+`
+
+render(
+  <SomeComp>
+    <AnotherComp color="green" />
+  </SomeComp>
+)
+```
+
+More documentation is available at [https://emotion.sh/docs/styled](https://emotion.sh/docs/styled).

package/node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require("./emotion-styled-base.browser.cjs.js").default;

package/node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.cjs.js

@@ -0,0 +1,198 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _extends = require('@babel/runtime/helpers/extends');
+var react = require('@emotion/react');
+var serialize = require('@emotion/serialize');
+var useInsertionEffectWithFallbacks = require('@emotion/use-insertion-effect-with-fallbacks');
+var utils = require('@emotion/utils');
+var React = require('react');
+var isPropValid = require('@emotion/is-prop-valid');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var isPropValid__default = /*#__PURE__*/_interopDefault(isPropValid);
+
+var isDevelopment = false;
+
+var testOmitPropsOnStringTag = isPropValid__default["default"];
+
+var testOmitPropsOnComponent = function testOmitPropsOnComponent(key) {
+  return key !== 'theme';
+};
+
+var getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag) {
+  return typeof tag === 'string' && // 96 is one less than the char code
+  // for "a" so this is checking that
+  // it's a lowercase character
+  tag.charCodeAt(0) > 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent;
+};
+var composeShouldForwardProps = function composeShouldForwardProps(tag, options, isReal) {
+  var shouldForwardProp;
+
+  if (options) {
+    var optionsShouldForwardProp = options.shouldForwardProp;
+    shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function (propName) {
+      return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName);
+    } : optionsShouldForwardProp;
+  }
+
+  if (typeof shouldForwardProp !== 'function' && isReal) {
+    shouldForwardProp = tag.__emotion_forwardProp;
+  }
+
+  return shouldForwardProp;
+};
+
+var Insertion = function Insertion(_ref) {
+  var cache = _ref.cache,
+      serialized = _ref.serialized,
+      isStringTag = _ref.isStringTag;
+  utils.registerStyles(cache, serialized, isStringTag);
+  useInsertionEffectWithFallbacks.useInsertionEffectAlwaysWithSyncFallback(function () {
+    return utils.insertStyles(cache, serialized, isStringTag);
+  });
+
+  return null;
+};
+
+var createStyled = function createStyled(tag, options) {
+
+  var isReal = tag.__emotion_real === tag;
+  var baseTag = isReal && tag.__emotion_base || tag;
+  var identifierName;
+  var targetClassName;
+
+  if (options !== undefined) {
+    identifierName = options.label;
+    targetClassName = options.target;
+  }
+
+  var shouldForwardProp = composeShouldForwardProps(tag, options, isReal);
+  var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag);
+  var shouldUseAs = !defaultShouldForwardProp('as');
+  return function () {
+    // eslint-disable-next-line prefer-rest-params
+    var args = arguments;
+    var styles = isReal && tag.__emotion_styles !== undefined ? tag.__emotion_styles.slice(0) : [];
+
+    if (identifierName !== undefined) {
+      styles.push("label:" + identifierName + ";");
+    }
+
+    if (args[0] == null || args[0].raw === undefined) {
+      // eslint-disable-next-line prefer-spread
+      styles.push.apply(styles, args);
+    } else {
+      var templateStringsArr = args[0];
+
+      styles.push(templateStringsArr[0]);
+      var len = args.length;
+      var i = 1;
+
+      for (; i < len; i++) {
+
+        styles.push(args[i], templateStringsArr[i]);
+      }
+    }
+
+    var Styled = react.withEmotionCache(function (props, cache, ref) {
+      var FinalTag = shouldUseAs && props.as || baseTag;
+      var className = '';
+      var classInterpolations = [];
+      var mergedProps = props;
+
+      if (props.theme == null) {
+        mergedProps = {};
+
+        for (var key in props) {
+          mergedProps[key] = props[key];
+        }
+
+        mergedProps.theme = React__namespace.useContext(react.ThemeContext);
+      }
+
+      if (typeof props.className === 'string') {
+        className = utils.getRegisteredStyles(cache.registered, classInterpolations, props.className);
+      } else if (props.className != null) {
+        className = props.className + " ";
+      }
+
+      var serialized = serialize.serializeStyles(styles.concat(classInterpolations), cache.registered, mergedProps);
+      className += cache.key + "-" + serialized.name;
+
+      if (targetClassName !== undefined) {
+        className += " " + targetClassName;
+      }
+
+      var finalShouldForwardProp = shouldUseAs && shouldForwardProp === undefined ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp;
+      var newProps = {};
+
+      for (var _key in props) {
+        if (shouldUseAs && _key === 'as') continue;
+
+        if (finalShouldForwardProp(_key)) {
+          newProps[_key] = props[_key];
+        }
+      }
+
+      newProps.className = className;
+
+      if (ref) {
+        newProps.ref = ref;
+      }
+
+      return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(Insertion, {
+        cache: cache,
+        serialized: serialized,
+        isStringTag: typeof FinalTag === 'string'
+      }), /*#__PURE__*/React__namespace.createElement(FinalTag, newProps));
+    });
+    Styled.displayName = identifierName !== undefined ? identifierName : "Styled(" + (typeof baseTag === 'string' ? baseTag : baseTag.displayName || baseTag.name || 'Component') + ")";
+    Styled.defaultProps = tag.defaultProps;
+    Styled.__emotion_real = Styled;
+    Styled.__emotion_base = baseTag;
+    Styled.__emotion_styles = styles;
+    Styled.__emotion_forwardProp = shouldForwardProp;
+    Object.defineProperty(Styled, 'toString', {
+      value: function value() {
+        if (targetClassName === undefined && isDevelopment) {
+          return 'NO_COMPONENT_SELECTOR';
+        }
+
+        return "." + targetClassName;
+      }
+    });
+
+    Styled.withComponent = function (nextTag, nextOptions) {
+      var newStyled = createStyled(nextTag, _extends({}, options, nextOptions, {
+        shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true)
+      }));
+      return newStyled.apply(void 0, styles);
+    };
+
+    return Styled;
+  };
+};
+
+exports["default"] = createStyled;

package/node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.cjs.mjs

@@ -0,0 +1,2 @@
+import "./emotion-styled-base.browser.cjs.js";
+export { _default as default } from "./emotion-styled-base.browser.cjs.default.js";