@sitecore/sc-contenthub-blok 0.0.91 → 1.0.2

package/node_modules/@emotion/react/src/jsx.js

@@ -1,25 +0,0 @@
-import * as React from 'react'
-import Emotion, { createEmotionProps } from './emotion-element'
-import { hasOwn } from './utils'
-
-export const jsx /*: typeof React.createElement */ = function (
-  type /*: React.ElementType */,
-  props /*: Object */
-) {
-  let args = arguments
-
-  if (props == null || !hasOwn.call(props, 'css')) {
-    return React.createElement.apply(undefined, args)
-  }
-
-  let argsLength = args.length
-  let createElementArgArray = new Array(argsLength)
-  createElementArgArray[0] = Emotion
-  createElementArgArray[1] = createEmotionProps(type, props)
-
-  for (let i = 2; i < argsLength; i++) {
-    createElementArgArray[i] = args[i]
-  }
-
-  return React.createElement.apply(null, createElementArgArray)
-}

package/node_modules/@emotion/react/src/keyframes.js

@@ -1,23 +0,0 @@
-import css from './css'
-
-/*
-type Keyframes = {|
-  name: string,
-  styles: string,
-  anim: 1,
-  toString: () => string
-|} & string
-*/
-
-export const keyframes = (...args) /*: Keyframes */ => {
-  let insertable = css(...args)
-  const name = `animation-${insertable.name}`
-  return {
-    name,
-    styles: `@keyframes ${name}{${insertable.styles}}`,
-    anim: 1,
-    toString() {
-      return `_EMO_${this.name}_${this.styles}_EMO_`
-    }
-  }
-}

package/node_modules/@emotion/react/types/index.d.ts

@@ -1,115 +0,0 @@
-// Definitions by: Junyoung Clare Jang <https://github.com/Ailrun>
-// TypeScript Version: 3.4
-
-import { EmotionCache } from '@emotion/cache'
-import {
-  ArrayInterpolation,
-  ComponentSelector,
-  CSSInterpolation,
-  CSSObject,
-  FunctionInterpolation,
-  Interpolation,
-  Keyframes,
-  SerializedStyles
-} from '@emotion/serialize'
-import {
-  ClassAttributes,
-  Context,
-  Provider,
-  FC,
-  ReactElement,
-  ReactNode,
-  Ref,
-  createElement
-} from 'react'
-import { EmotionJSX } from './jsx-namespace'
-
-export {
-  ArrayInterpolation,
-  ComponentSelector,
-  CSSObject,
-  EmotionCache,
-  FunctionInterpolation,
-  Interpolation,
-  Keyframes,
-  SerializedStyles
-}
-
-export * from './theming'
-export * from './helper'
-
-// tslint:disable-next-line: no-empty-interface
-export interface Theme {}
-
-export const ThemeContext: Context<object>
-export const CacheProvider: Provider<EmotionCache>
-export function withEmotionCache<Props, RefType = any>(
-  func: (props: Props, context: EmotionCache, ref: Ref<RefType>) => ReactNode
-): FC<Props & ClassAttributes<RefType>>
-
-export function css(
-  template: TemplateStringsArray,
-  ...args: Array<CSSInterpolation>
-): SerializedStyles
-export function css(...args: Array<CSSInterpolation>): SerializedStyles
-
-export interface GlobalProps {
-  styles: Interpolation<Theme>
-}
-
-/**
- * @desc
- * JSX generic are supported only after TS@2.9
- */
-export function Global(props: GlobalProps): ReactElement
-
-export function keyframes(
-  template: TemplateStringsArray,
-  ...args: Array<CSSInterpolation>
-): Keyframes
-export function keyframes(...args: Array<CSSInterpolation>): Keyframes
-
-export interface ArrayClassNamesArg extends Array<ClassNamesArg> {}
-export type ClassNamesArg =
-  | undefined
-  | null
-  | string
-  | boolean
-  | { [className: string]: boolean | null | undefined }
-  | ArrayClassNamesArg
-
-export interface ClassNamesContent {
-  css(template: TemplateStringsArray, ...args: Array<CSSInterpolation>): string
-  css(...args: Array<CSSInterpolation>): string
-  cx(...args: Array<ClassNamesArg>): string
-  theme: Theme
-}
-export interface ClassNamesProps {
-  children(content: ClassNamesContent): ReactNode
-}
-/**
- * @desc
- * JSX generic are supported only after TS@2.9
- */
-export function ClassNames(props: ClassNamesProps): ReactElement
-
-export const jsx: typeof createElement
-export namespace jsx {
-  namespace JSX {
-    type ElementType = EmotionJSX.ElementType
-    interface Element extends EmotionJSX.Element {}
-    interface ElementClass extends EmotionJSX.ElementClass {}
-    interface ElementAttributesProperty
-      extends EmotionJSX.ElementAttributesProperty {}
-    interface ElementChildrenAttribute
-      extends EmotionJSX.ElementChildrenAttribute {}
-    type LibraryManagedAttributes<C, P> = EmotionJSX.LibraryManagedAttributes<
-      C,
-      P
-    >
-    interface IntrinsicAttributes extends EmotionJSX.IntrinsicAttributes {}
-    interface IntrinsicClassAttributes<T>
-      extends EmotionJSX.IntrinsicClassAttributes<T> {}
-    type IntrinsicElements = EmotionJSX.IntrinsicElements
-  }
-}

package/node_modules/@emotion/react/types/jsx-dev-runtime.d.ts

@@ -1 +0,0 @@
-export { EmotionJSX as JSX } from './jsx-namespace'

package/node_modules/@emotion/react/types/jsx-namespace.d.ts

@@ -1,102 +0,0 @@
-import 'react'
-import { Interpolation } from '@emotion/serialize'
-import { Theme } from '@emotion/react'
-
-type IsPreReact19 = 2 extends Parameters<React.FunctionComponent<any>>['length']
-  ? true
-  : false
-
-type WithConditionalCSSProp<P> = 'className' extends keyof P
-  ? string extends P['className' & keyof P]
-    ? { css?: Interpolation<Theme> }
-    : {}
-  : {}
-
-// unpack all here to avoid infinite self-referencing when defining our own JSX namespace for the pre-React 19 case
-type ReactJSXElement = true extends IsPreReact19
-  ? /** @ts-ignore */
-    JSX.Element
-  : /** @ts-ignore */
-    React.JSX.Element
-type ReactJSXElementClass = true extends IsPreReact19
-  ? /** @ts-ignore */
-    JSX.ElementClass
-  : /** @ts-ignore */
-    React.JSX.ElementClass
-type ReactJSXElementAttributesProperty = true extends IsPreReact19
-  ? /** @ts-ignore */
-    JSX.ElementAttributesProperty
-  : /** @ts-ignore */
-    React.JSX.ElementAttributesProperty
-type ReactJSXElementChildrenAttribute = true extends IsPreReact19
-  ? /** @ts-ignore */
-    JSX.ElementChildrenAttribute
-  : /** @ts-ignore */
-    React.JSX.ElementChildrenAttribute
-type ReactJSXLibraryManagedAttributes<C, P> = true extends IsPreReact19
-  ? /** @ts-ignore */
-    JSX.LibraryManagedAttributes<C, P>
-  : /** @ts-ignore */
-    React.JSX.LibraryManagedAttributes<C, P>
-type ReactJSXIntrinsicAttributes = true extends IsPreReact19
-  ? /** @ts-ignore */
-    JSX.IntrinsicAttributes
-  : /** @ts-ignore */
-    React.JSX.IntrinsicAttributes
-type ReactJSXIntrinsicClassAttributes<T> = true extends IsPreReact19
-  ? /** @ts-ignore */
-    JSX.IntrinsicClassAttributes<T>
-  : /** @ts-ignore */
-    React.JSX.IntrinsicClassAttributes<T>
-type ReactJSXIntrinsicElements = true extends IsPreReact19
-  ? /** @ts-ignore */
-    JSX.IntrinsicElements
-  : /** @ts-ignore */
-    React.JSX.IntrinsicElements
-
-type ReactJSXElementType = true extends IsPreReact19
-  ? // based on the code from @types/react@18.2.8
-    // https://github.com/DefinitelyTyped/DefinitelyTyped/blob/3197efc097d522c4bf02b94e1a0766d007d6cdeb/types/react/index.d.ts#LL3204C13-L3204C13
-    string | React.JSXElementConstructor<any>
-  : /** @ts-ignore */
-    React.JSX.ElementType
-
-export namespace ReactJSX {
-  type ElementType = ReactJSXElementType
-  interface Element extends ReactJSXElement {}
-  interface ElementClass extends ReactJSXElementClass {}
-  interface ElementAttributesProperty
-    extends ReactJSXElementAttributesProperty {}
-  interface ElementChildrenAttribute extends ReactJSXElementChildrenAttribute {}
-
-  type LibraryManagedAttributes<C, P> = ReactJSXLibraryManagedAttributes<C, P>
-
-  interface IntrinsicAttributes extends ReactJSXIntrinsicAttributes {}
-  interface IntrinsicClassAttributes<T>
-    extends ReactJSXIntrinsicClassAttributes<T> {}
-
-  type IntrinsicElements = ReactJSXIntrinsicElements
-}
-
-export namespace EmotionJSX {
-  type ElementType = ReactJSXElementType
-  interface Element extends ReactJSXElement {}
-  interface ElementClass extends ReactJSXElementClass {}
-  interface ElementAttributesProperty
-    extends ReactJSXElementAttributesProperty {}
-  interface ElementChildrenAttribute extends ReactJSXElementChildrenAttribute {}
-
-  type LibraryManagedAttributes<C, P> = P extends unknown
-    ? WithConditionalCSSProp<P> & ReactJSXLibraryManagedAttributes<C, P>
-    : never
-
-  interface IntrinsicAttributes extends ReactJSXIntrinsicAttributes {}
-  interface IntrinsicClassAttributes<T>
-    extends ReactJSXIntrinsicClassAttributes<T> {}
-
-  type IntrinsicElements = {
-    [K in keyof ReactJSXIntrinsicElements]: ReactJSXIntrinsicElements[K] & {
-      css?: Interpolation<Theme>
-    }
-  }
-}

package/node_modules/@emotion/react/types/jsx-runtime.d.ts

@@ -1 +0,0 @@
-export { EmotionJSX as JSX } from './jsx-namespace'

package/node_modules/@emotion/react/types/theming.d.ts

@@ -1,31 +0,0 @@
-// Definitions by: Junyoung Clare Jang <https://github.com/Ailrun>
-// TypeScript Version: 3.1
-
-import * as React from 'react'
-import { Theme } from '@emotion/react'
-import { DistributiveOmit, PropsOf } from './helper'
-
-export interface ThemeProviderProps {
-  theme: Partial<Theme> | ((outerTheme: Theme) => Theme)
-  children: React.ReactNode
-}
-
-export interface ThemeProvider {
-  (props: ThemeProviderProps): React.ReactElement
-}
-
-export type withTheme = <
-  C extends React.ComponentType<React.ComponentProps<C>>
->(
-  component: C
-) => React.FC<DistributiveOmit<PropsOf<C>, 'theme'> & { theme?: Theme }>
-
-export function useTheme(): Theme
-
-export const ThemeProvider: ThemeProvider
-
-export const withTheme: withTheme
-
-export type WithTheme<P, T> = P extends { theme: infer Theme }
-  ? P & { theme: Exclude<Theme, undefined> }
-  : P & { theme: T }

package/node_modules/@emotion/styled/dist/declarations/types/base.d.ts

@@ -1,197 +0,0 @@
-// Definitions by: Junyoung Clare Jang <https://github.com/Ailrun>
-// TypeScript Version: 3.2
-
-import * as React from 'react'
-import { ComponentSelector, Interpolation } from '@emotion/serialize'
-import { PropsOf, Theme } from '@emotion/react'
-import { ReactJSXIntrinsicElements } from "./jsx-namespace.js"
-
-export {
-  ArrayInterpolation,
-  CSSObject,
-  FunctionInterpolation
-} from '@emotion/serialize'
-
-export { ComponentSelector, Interpolation }
-
-/** Same as StyledOptions but shouldForwardProp must be a type guard */
-export interface FilteringStyledOptions<
-  Props = Record<string, any>,
-  ForwardedProps extends keyof Props & string = keyof Props & string
-> {
-  label?: string
-  shouldForwardProp?: (propName: string) => propName is ForwardedProps
-  target?: string
-}
-
-export interface StyledOptions<Props = Record<string, any>> {
-  label?: string
-  shouldForwardProp?: (propName: string) => boolean
-  target?: string
-}
-
-/**
- * @typeparam ComponentProps  Props which will be included when withComponent is called
- * @typeparam SpecificComponentProps  Props which will *not* be included when withComponent is called
- */
-export interface StyledComponent<
-  ComponentProps extends {},
-  SpecificComponentProps extends {} = {},
-  JSXProps extends {} = {}
-> extends React.FC<ComponentProps & SpecificComponentProps & JSXProps>,
-    ComponentSelector {
-  withComponent<C extends React.ComponentClass<React.ComponentProps<C>>>(
-    component: C
-  ): StyledComponent<
-    ComponentProps & PropsOf<C>,
-    {},
-    { ref?: React.Ref<InstanceType<C>> }
-  >
-  withComponent<C extends React.ComponentType<React.ComponentProps<C>>>(
-    component: C
-  ): StyledComponent<ComponentProps & PropsOf<C>>
-  withComponent<Tag extends keyof ReactJSXIntrinsicElements>(
-    tag: Tag
-  ): StyledComponent<ComponentProps, ReactJSXIntrinsicElements[Tag]>
-}
-
-/**
- * @typeparam ComponentProps  Props which will be included when withComponent is called
- * @typeparam SpecificComponentProps  Props which will *not* be included when withComponent is called
- */
-export interface CreateStyledComponent<
-  ComponentProps extends {},
-  SpecificComponentProps extends {} = {},
-  JSXProps extends {} = {}
-> {
-  (
-    template: TemplateStringsArray,
-    ...styles: Array<
-      Interpolation<ComponentProps & SpecificComponentProps & { theme: Theme }>
-    >
-  ): StyledComponent<ComponentProps, SpecificComponentProps, JSXProps>
-
-  /**
-   * @typeparam AdditionalProps  Additional props to add to your styled component
-   */
-  <AdditionalProps extends {}>(
-    template: TemplateStringsArray,
-    ...styles: Array<
-      Interpolation<
-        ComponentProps &
-          SpecificComponentProps &
-          AdditionalProps & { theme: Theme }
-      >
-    >
-  ): StyledComponent<
-    ComponentProps & AdditionalProps,
-    SpecificComponentProps,
-    JSXProps
-  >
-
-  /**
-   * @typeparam AdditionalProps  Additional props to add to your styled component
-   */
-  <AdditionalProps extends {} = {}>(
-    ...styles: Array<
-      Interpolation<
-        ComponentProps &
-          SpecificComponentProps &
-          AdditionalProps & { theme: Theme }
-      >
-    >
-  ): StyledComponent<
-    ComponentProps & AdditionalProps,
-    SpecificComponentProps,
-    JSXProps
-  >
-}
-
-/**
- * @desc
- * This function accepts a React component or tag ('div', 'a' etc).
- *
- * @example styled(MyComponent)({ width: 100 })
- * @example styled(MyComponent)(myComponentProps => ({ width: myComponentProps.width })
- * @example styled('div')({ width: 100 })
- * @example styled('div')<Props>(props => ({ width: props.width })
- */
-export interface CreateStyled {
-  <
-    C extends React.ComponentClass<React.ComponentProps<C>>,
-    ForwardedProps extends keyof React.ComponentProps<C> &
-      string = keyof React.ComponentProps<C> & string
-  >(
-    component: C,
-    options: FilteringStyledOptions<React.ComponentProps<C>, ForwardedProps>
-  ): CreateStyledComponent<
-    Pick<PropsOf<C>, ForwardedProps> & {
-      theme?: Theme
-    },
-    {},
-    {
-      ref?: React.Ref<InstanceType<C>>
-    }
-  >
-
-  <C extends React.ComponentClass<React.ComponentProps<C>>>(
-    component: C,
-    options?: StyledOptions<React.ComponentProps<C>>
-  ): CreateStyledComponent<
-    PropsOf<C> & {
-      theme?: Theme
-    },
-    {},
-    {
-      ref?: React.Ref<InstanceType<C>>
-    }
-  >
-
-  <
-    C extends React.ComponentType<React.ComponentProps<C>>,
-    ForwardedProps extends keyof React.ComponentProps<C> &
-      string = keyof React.ComponentProps<C> & string
-  >(
-    component: C,
-    options: FilteringStyledOptions<React.ComponentProps<C>, ForwardedProps>
-  ): CreateStyledComponent<
-    Pick<PropsOf<C>, ForwardedProps> & {
-      theme?: Theme
-    }
-  >
-
-  <C extends React.ComponentType<React.ComponentProps<C>>>(
-    component: C,
-    options?: StyledOptions<React.ComponentProps<C>>
-  ): CreateStyledComponent<
-    PropsOf<C> & {
-      theme?: Theme
-    }
-  >
-
-  <
-    Tag extends keyof ReactJSXIntrinsicElements,
-    ForwardedProps extends keyof ReactJSXIntrinsicElements[Tag] &
-      string = keyof ReactJSXIntrinsicElements[Tag] & string
-  >(
-    tag: Tag,
-    options: FilteringStyledOptions<
-      ReactJSXIntrinsicElements[Tag],
-      ForwardedProps
-    >
-  ): CreateStyledComponent<
-    { theme?: Theme; as?: React.ElementType },
-    Pick<ReactJSXIntrinsicElements[Tag], ForwardedProps>
-  >
-
-  <Tag extends keyof ReactJSXIntrinsicElements>(
-    tag: Tag,
-    options?: StyledOptions<ReactJSXIntrinsicElements[Tag]>
-  ): CreateStyledComponent<
-    { theme?: Theme; as?: React.ElementType },
-    ReactJSXIntrinsicElements[Tag]
-  >
-}
-
-declare const styled: CreateStyled
-export default styled

package/node_modules/@emotion/styled/dist/declarations/types/index.d.ts

@@ -1,33 +0,0 @@
-// Definitions by: Junyoung Clare Jang <https://github.com/Ailrun>
-// TypeScript Version: 3.2
-
-import { Theme } from '@emotion/react'
-import { CreateStyled as BaseCreateStyled, CreateStyledComponent } from "./base.js"
-import { ReactJSXIntrinsicElements } from "./jsx-namespace.js"
-
-export {
-  ArrayInterpolation,
-  ComponentSelector,
-  CSSObject,
-  FunctionInterpolation,
-  Interpolation,
-  StyledComponent,
-  StyledOptions,
-  FilteringStyledOptions,
-  CreateStyledComponent
-} from "./base.js"
-
-export type StyledTags = {
-  [Tag in keyof ReactJSXIntrinsicElements]: CreateStyledComponent<
-    {
-      theme?: Theme
-      as?: React.ElementType
-    },
-    ReactJSXIntrinsicElements[Tag]
-  >
-}
-
-export interface CreateStyled extends BaseCreateStyled, StyledTags {}
-
-declare const styled: CreateStyled
-export default styled

package/node_modules/@emotion/styled/src/base.d.ts

@@ -1,2 +0,0 @@
-export * from '../types/base'
-export { default } from '../types/base'

package/node_modules/@emotion/styled/src/index.d.ts

@@ -1,2 +0,0 @@
-export * from '../types'
-export { default } from '../types'

package/node_modules/@emotion/styled/src/index.js

@@ -1,11 +0,0 @@
-import styled from './base'
-import { tags } from './tags'
-
-// bind it to avoid mutating the original function
-const newStyled = styled.bind()
-
-tags.forEach(tagName => {
-  newStyled[tagName] = newStyled(tagName)
-})
-
-export default newStyled

package/node_modules/@emotion/styled/src/utils.js

@@ -1,86 +0,0 @@
-/* import type {
-  ElementType,
-  StatelessFunctionalComponent,
-  AbstractComponent
-} from 'react' */
-import isPropValid from '@emotion/is-prop-valid'
-
-/*
-export type Interpolations = Array<any>
-
-export type StyledElementType<Props> =
-  | string
-  | AbstractComponent<{ ...Props, className: string }, mixed>
-
-export type StyledOptions = {
-  label?: string,
-  shouldForwardProp?: string => boolean,
-  target?: string
-}
-
-export type StyledComponent<Props> = StatelessFunctionalComponent<Props> & {
-  defaultProps: any,
-  toString: () => string,
-  withComponent: (
-    nextTag: StyledElementType<Props>,
-    nextOptions?: StyledOptions
-  ) => StyledComponent<Props>
-}
-
-export type PrivateStyledComponent<Props> = StyledComponent<Props> & {
-  __emotion_real: StyledComponent<Props>,
-  __emotion_base: any,
-  __emotion_styles: any,
-  __emotion_forwardProp: any
-}
-*/
-
-const testOmitPropsOnStringTag = isPropValid
-const testOmitPropsOnComponent = (key /*: string */) => key !== 'theme'
-
-export const getDefaultShouldForwardProp = (tag /*: ElementType */) =>
-  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
-
-export const composeShouldForwardProps = (
-  tag /*: PrivateStyledComponent<any> */,
-  options /*: StyledOptions | void */,
-  isReal /*: boolean */
-) => {
-  let shouldForwardProp
-  if (options) {
-    const optionsShouldForwardProp = options.shouldForwardProp
-    shouldForwardProp =
-      tag.__emotion_forwardProp && optionsShouldForwardProp
-        ? (propName /*: string */) =>
-            tag.__emotion_forwardProp(propName) &&
-            optionsShouldForwardProp(propName)
-        : optionsShouldForwardProp
-  }
-
-  if (typeof shouldForwardProp !== 'function' && isReal) {
-    shouldForwardProp = tag.__emotion_forwardProp
-  }
-
-  return shouldForwardProp
-}
-
-/*
-export type CreateStyledComponent = <Props>(
-  ...args: Interpolations
-) => StyledComponent<Props>
-
-export type CreateStyled = {
-  <Props>(
-    tag: StyledElementType<Props>,
-    options?: StyledOptions
-  ): (...args: Interpolations) => StyledComponent<Props>,
-  [key: string]: CreateStyledComponent,
-  bind: () => CreateStyled
-}
-*/

package/node_modules/@emotion/styled/types/jsx-namespace.d.ts

@@ -1,14 +0,0 @@
-// this is basically a slimmed down copy of https://github.com/emotion-js/emotion/blob/main/packages/react/types/jsx-namespace.d.ts
-// it helps to avoid issues when combining newer `@emotion/styled` and older `@emotion/react` versions
-// in such setup, ReactJSX namespace won't exist in `@emotion/react` and that would lead to errors
-import 'react'
-
-type IsPreReact19 = 2 extends Parameters<React.FunctionComponent<any>>['length']
-  ? true
-  : false
-
-export type ReactJSXIntrinsicElements = true extends IsPreReact19
-  ? /** @ts-ignore */
-    JSX.IntrinsicElements
-  : /** @ts-ignore */
-    React.JSX.IntrinsicElements

package/node_modules/@emotion/use-insertion-effect-with-fallbacks/src/index.js

@@ -1,15 +0,0 @@
-import * as React from 'react'
-import isBrowser from '#is-browser'
-
-const syncFallback = create => create()
-
-const useInsertionEffect = React['useInsertion' + 'Effect']
-  ? React['useInsertion' + 'Effect']
-  : false
-
-export const useInsertionEffectAlwaysWithSyncFallback = !isBrowser
-  ? syncFallback
-  : useInsertionEffect || syncFallback
-
-export const useInsertionEffectWithLayoutFallback =
-  useInsertionEffect || React.useLayoutEffect

package/node_modules/@jridgewell/gen-mapping/dist/types/sourcemap-segment.d.ts

@@ -1,12 +0,0 @@
-declare type GeneratedColumn = number;
-declare type SourcesIndex = number;
-declare type SourceLine = number;
-declare type SourceColumn = number;
-declare type NamesIndex = number;
-export declare type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
-export declare const COLUMN = 0;
-export declare const SOURCES_INDEX = 1;
-export declare const SOURCE_LINE = 2;
-export declare const SOURCE_COLUMN = 3;
-export declare const NAMES_INDEX = 4;
-export {};