@polymarket-developers/clob-client 1.0.7

package/cache/src/index.js

@@ -0,0 +1,257 @@
+import { StyleSheet } from '@emotion/sheet'
+/* import { type EmotionCache, type SerializedStyles } from '@emotion/utils' */
+import {
+  serialize,
+  compile,
+  middleware,
+  rulesheet,
+  stringify,
+  COMMENT
+} from 'stylis'
+import weakMemoize from '@emotion/weak-memoize'
+import memoize from '@emotion/memoize'
+import isDevelopment from '#is-development'
+import isBrowser from '#is-browser'
+import {
+  compat,
+  removeLabel,
+  createUnsafeSelectorsAlarm,
+  incorrectImportAlarm
+} from './stylis-plugins'
+import { prefixer } from './prefixer'
+/* import type { StylisPlugin } from './types' */
+
+/*
+export type Options = {
+  nonce?: string,
+  stylisPlugins?: StylisPlugin[],
+  key: string,
+  container?: HTMLElement,
+  speedy?: boolean,
+  prepend?: boolean,
+  insertionPoint?: HTMLElement
+}
+*/
+
+let getServerStylisCache = isBrowser
+  ? undefined
+  : weakMemoize(() =>
+      memoize(() => {
+        let cache = {}
+        return name => cache[name]
+      })
+    )
+
+const defaultStylisPlugins = [prefixer]
+
+let createCache = (options /*: Options */) /*: EmotionCache */ => {
+  let key = options.key
+
+  if (isDevelopment && !key) {
+    throw new Error(
+      "You have to configure `key` for your cache. Please make sure it's unique (and not equal to 'css') as it's used for linking styles to your cache.\n" +
+        `If multiple caches share the same key they might "fight" for each other's style elements.`
+    )
+  }
+
+  if (isBrowser && key === 'css') {
+    const ssrStyles = document.querySelectorAll(
+      `style[data-emotion]:not([data-s])`
+    )
+
+    // get SSRed styles out of the way of React's hydration
+    // document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be)
+    // note this very very intentionally targets all style elements regardless of the key to ensure
+    // that creating a cache works inside of render of a React component
+    Array.prototype.forEach.call(ssrStyles, (node /*: HTMLStyleElement */) => {
+      // we want to only move elements which have a space in the data-emotion attribute value
+      // because that indicates that it is an Emotion 11 server-side rendered style elements
+      // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector
+      // Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes)
+      // so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles
+      // will not result in the Emotion 10 styles being destroyed
+      const dataEmotionAttribute = node.getAttribute('data-emotion')
+      if (dataEmotionAttribute.indexOf(' ') === -1) {
+        return
+      }
+
+      document.head.appendChild(node)
+      node.setAttribute('data-s', '')
+    })
+  }
+
+  const stylisPlugins = options.stylisPlugins || defaultStylisPlugins
+
+  if (isDevelopment) {
+    if (/[^a-z-]/.test(key)) {
+      throw new Error(
+        `Emotion key must only contain lower case alphabetical characters and - but "${key}" was passed`
+      )
+    }
+  }
+  let inserted = {}
+  let container /* : Node */
+  const nodesToHydrate = []
+  if (isBrowser) {
+    container = options.container || document.head
+
+    Array.prototype.forEach.call(
+      // this means we will ignore elements which don't have a space in them which
+      // means that the style elements we're looking at are only Emotion 11 server-rendered style elements
+      document.querySelectorAll(`style[data-emotion^="${key} "]`),
+      (node /*: HTMLStyleElement */) => {
+        const attrib = node.getAttribute(`data-emotion`).split(' ')
+        for (let i = 1; i < attrib.length; i++) {
+          inserted[attrib[i]] = true
+        }
+        nodesToHydrate.push(node)
+      }
+    )
+  }
+
+  let insert /*: (
+    selector: string,
+    serialized: SerializedStyles,
+    sheet: StyleSheet,
+    shouldCache: boolean
+  ) => string | void */
+  const omnipresentPlugins = [compat, removeLabel]
+
+  if (isDevelopment) {
+    omnipresentPlugins.push(
+      createUnsafeSelectorsAlarm({
+        get compat() {
+          return cache.compat
+        }
+      }),
+      incorrectImportAlarm
+    )
+  }
+
+  if (isBrowser) {
+    let currentSheet
+
+    const finalizingPlugins = [
+      stringify,
+      isDevelopment
+        ? element => {
+            if (!element.root) {
+              if (element.return) {
+                currentSheet.insert(element.return)
+              } else if (element.value && element.type !== COMMENT) {
+                // insert empty rule in non-production environments
+                // so @emotion/jest can grab `key` from the (JS)DOM for caches without any rules inserted yet
+                currentSheet.insert(`${element.value}{}`)
+              }
+            }
+          }
+        : rulesheet(rule => {
+            currentSheet.insert(rule)
+          })
+    ]
+
+    const serializer = middleware(
+      omnipresentPlugins.concat(stylisPlugins, finalizingPlugins)
+    )
+    const stylis = styles => serialize(compile(styles), serializer)
+
+    insert = (
+      selector /*: string */,
+      serialized /*: SerializedStyles */,
+      sheet /*: StyleSheet */,
+      shouldCache /*: boolean */
+    ) /*: void */ => {
+      currentSheet = sheet
+      if (isDevelopment && serialized.map !== undefined) {
+        currentSheet = {
+          insert: (rule /*: string */) => {
+            sheet.insert(rule + serialized.map)
+          }
+        }
+      }
+
+      stylis(selector ? `${selector}{${serialized.styles}}` : serialized.styles)
+
+      if (shouldCache) {
+        cache.inserted[serialized.name] = true
+      }
+    }
+  } else {
+    const finalizingPlugins = [stringify]
+    const serializer = middleware(
+      omnipresentPlugins.concat(stylisPlugins, finalizingPlugins)
+    )
+    const stylis = styles => serialize(compile(styles), serializer)
+
+    let serverStylisCache = getServerStylisCache(stylisPlugins)(key)
+    let getRules = (
+      selector /*: string */,
+      serialized /*: SerializedStyles */
+    ) /*: string */ => {
+      let name = serialized.name
+      if (serverStylisCache[name] === undefined) {
+        serverStylisCache[name] = stylis(
+          selector ? `${selector}{${serialized.styles}}` : serialized.styles
+        )
+      }
+      return serverStylisCache[name]
+    }
+    insert = (
+      selector /*: string */,
+      serialized /*: SerializedStyles */,
+      sheet /*: StyleSheet */,
+      shouldCache /*: boolean */
+    ) /*: string | void */ => {
+      let name = serialized.name
+      let rules = getRules(selector, serialized)
+      if (cache.compat === undefined) {
+        // in regular mode, we don't set the styles on the inserted cache
+        // since we don't need to and that would be wasting memory
+        // we return them so that they are rendered in a style tag
+        if (shouldCache) {
+          cache.inserted[name] = true
+        }
+        if (isDevelopment && serialized.map !== undefined) {
+          return rules + serialized.map
+        }
+        return rules
+      } else {
+        // in compat mode, we put the styles on the inserted cache so
+        // that emotion-server can pull out the styles
+        // except when we don't want to cache it which was in Global but now
+        // is nowhere but we don't want to do a major right now
+        // and just in case we're going to leave the case here
+        // it's also not affecting client side bundle size
+        // so it's really not a big deal
+
+        if (shouldCache) {
+          cache.inserted[name] = rules
+        } else {
+          return rules
+        }
+      }
+    }
+  }
+
+  const cache /*: EmotionCache */ = {
+    key,
+    sheet: new StyleSheet({
+      key,
+      container,
+      nonce: options.nonce,
+      speedy: options.speedy,
+      prepend: options.prepend,
+      insertionPoint: options.insertionPoint
+    }),
+    nonce: options.nonce,
+    inserted,
+    registered: {},
+    insert
+  }
+
+  cache.sheet.hydrate(nodesToHydrate)
+
+  return cache
+}
+
+export default createCache

package/cache/src/prefixer.js

@@ -0,0 +1,340 @@
+/* eslint-disable no-fallthrough */
+/* eslint-disable eqeqeq */
+import {
+  charat,
+  combine,
+  copy,
+  DECLARATION,
+  hash,
+  indexof,
+  KEYFRAMES,
+  match,
+  MOZ,
+  MS,
+  replace,
+  RULESET,
+  serialize,
+  strlen,
+  WEBKIT
+} from 'stylis'
+
+// this is a copy of stylis@4.0.13 prefixer, the latter version introduced grid prefixing which we don't want
+
+function prefix(value, length) {
+  switch (hash(value, length)) {
+    // color-adjust
+    case 5103:
+      return WEBKIT + 'print-' + value + value
+    // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)
+    case 5737:
+    case 4201:
+    case 3177:
+    case 3433:
+    case 1641:
+    case 4457:
+    case 2921:
+    // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break
+    case 5572:
+    case 6356:
+    case 5844:
+    case 3191:
+    case 6645:
+    case 3005:
+    // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,
+    case 6391:
+    case 5879:
+    case 5623:
+    case 6135:
+    case 4599:
+    case 4855:
+    // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)
+    case 4215:
+    case 6389:
+    case 5109:
+    case 5365:
+    case 5621:
+    case 3829:
+      return WEBKIT + value + value
+    // appearance, user-select, transform, hyphens, text-size-adjust
+    case 5349:
+    case 4246:
+    case 4810:
+    case 6968:
+    case 2756:
+      return WEBKIT + value + MOZ + value + MS + value + value
+    // flex, flex-direction
+    case 6828:
+    case 4268:
+      return WEBKIT + value + MS + value + value
+    // order
+    case 6165:
+      return WEBKIT + value + MS + 'flex-' + value + value
+    // align-items
+    case 5187:
+      return (
+        WEBKIT +
+        value +
+        replace(
+          value,
+          /(\w+).+(:[^]+)/,
+          WEBKIT + 'box-$1$2' + MS + 'flex-$1$2'
+        ) +
+        value
+      )
+    // align-self
+    case 5443:
+      return (
+        WEBKIT +
+        value +
+        MS +
+        'flex-item-' +
+        replace(value, /flex-|-self/, '') +
+        value
+      )
+    // align-content
+    case 4675:
+      return (
+        WEBKIT +
+        value +
+        MS +
+        'flex-line-pack' +
+        replace(value, /align-content|flex-|-self/, '') +
+        value
+      )
+    // flex-shrink
+    case 5548:
+      return WEBKIT + value + MS + replace(value, 'shrink', 'negative') + value
+    // flex-basis
+    case 5292:
+      return (
+        WEBKIT + value + MS + replace(value, 'basis', 'preferred-size') + value
+      )
+    // flex-grow
+    case 6060:
+      return (
+        WEBKIT +
+        'box-' +
+        replace(value, '-grow', '') +
+        WEBKIT +
+        value +
+        MS +
+        replace(value, 'grow', 'positive') +
+        value
+      )
+    // transition
+    case 4554:
+      return (
+        WEBKIT +
+        replace(value, /([^-])(transform)/g, '$1' + WEBKIT + '$2') +
+        value
+      )
+    // cursor
+    case 6187:
+      return (
+        replace(
+          replace(
+            replace(value, /(zoom-|grab)/, WEBKIT + '$1'),
+            /(image-set)/,
+            WEBKIT + '$1'
+          ),
+          value,
+          ''
+        ) + value
+      )
+    // background, background-image
+    case 5495:
+    case 3959:
+      return replace(value, /(image-set\([^]*)/, WEBKIT + '$1' + '$`$1')
+    // justify-content
+    case 4968:
+      return (
+        replace(
+          replace(
+            value,
+            /(.+:)(flex-)?(.*)/,
+            WEBKIT + 'box-pack:$3' + MS + 'flex-pack:$3'
+          ),
+          /s.+-b[^;]+/,
+          'justify'
+        ) +
+        WEBKIT +
+        value +
+        value
+      )
+    // (margin|padding)-inline-(start|end)
+    case 4095:
+    case 3583:
+    case 4068:
+    case 2532:
+      return replace(value, /(.+)-inline(.+)/, WEBKIT + '$1$2') + value
+    // (min|max)?(width|height|inline-size|block-size)
+    case 8116:
+    case 7059:
+    case 5753:
+    case 5535:
+    case 5445:
+    case 5701:
+    case 4933:
+    case 4677:
+    case 5533:
+    case 5789:
+    case 5021:
+    case 4765:
+      // stretch, max-content, min-content, fill-available
+      if (strlen(value) - 1 - length > 6)
+        switch (charat(value, length + 1)) {
+          // (m)ax-content, (m)in-content
+          case 109:
+            // -
+            if (charat(value, length + 4) !== 45) break
+          // (f)ill-available, (f)it-content
+          case 102:
+            return (
+              replace(
+                value,
+                /(.+:)(.+)-([^]+)/,
+                '$1' +
+                  WEBKIT +
+                  '$2-$3' +
+                  '$1' +
+                  MOZ +
+                  (charat(value, length + 3) == 108 ? '$3' : '$2-$3')
+              ) + value
+            )
+          // (s)tretch
+          case 115:
+            return ~indexof(value, 'stretch')
+              ? prefix(replace(value, 'stretch', 'fill-available'), length) +
+                  value
+              : value
+        }
+      break
+    // position: sticky
+    case 4949:
+      // (s)ticky?
+      if (charat(value, length + 1) !== 115) break
+    // display: (flex|inline-flex)
+    case 6444:
+      switch (
+        charat(value, strlen(value) - 3 - (~indexof(value, '!important') && 10))
+      ) {
+        // stic(k)y
+        case 107:
+          return replace(value, ':', ':' + WEBKIT) + value
+        // (inline-)?fl(e)x
+        case 101:
+          return (
+            replace(
+              value,
+              /(.+:)([^;!]+)(;|!.+)?/,
+              '$1' +
+                WEBKIT +
+                (charat(value, 14) === 45 ? 'inline-' : '') +
+                'box$3' +
+                '$1' +
+                WEBKIT +
+                '$2$3' +
+                '$1' +
+                MS +
+                '$2box$3'
+            ) + value
+          )
+      }
+      break
+    // writing-mode
+    case 5936:
+      switch (charat(value, length + 11)) {
+        // vertical-l(r)
+        case 114:
+          return (
+            WEBKIT +
+            value +
+            MS +
+            replace(value, /[svh]\w+-[tblr]{2}/, 'tb') +
+            value
+          )
+        // vertical-r(l)
+        case 108:
+          return (
+            WEBKIT +
+            value +
+            MS +
+            replace(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') +
+            value
+          )
+        // horizontal(-)tb
+        case 45:
+          return (
+            WEBKIT +
+            value +
+            MS +
+            replace(value, /[svh]\w+-[tblr]{2}/, 'lr') +
+            value
+          )
+      }
+
+      return WEBKIT + value + MS + value + value
+  }
+
+  return value
+}
+
+export let prefixer = (element, index, children, callback) => {
+  if (element.length > -1)
+    if (!element.return)
+      switch (element.type) {
+        case DECLARATION:
+          element.return = prefix(element.value, element.length)
+          break
+        case KEYFRAMES:
+          return serialize(
+            [
+              copy(element, {
+                value: replace(element.value, '@', '@' + WEBKIT)
+              })
+            ],
+            callback
+          )
+        case RULESET:
+          if (element.length)
+            return combine(element.props, function (value) {
+              switch (match(value, /(::plac\w+|:read-\w+)/)) {
+                // :read-(only|write)
+                case ':read-only':
+                case ':read-write':
+                  return serialize(
+                    [
+                      copy(element, {
+                        props: [replace(value, /:(read-\w+)/, ':' + MOZ + '$1')]
+                      })
+                    ],
+                    callback
+                  )
+                // :placeholder
+                case '::placeholder':
+                  return serialize(
+                    [
+                      copy(element, {
+                        props: [
+                          replace(
+                            value,
+                            /:(plac\w+)/,
+                            ':' + WEBKIT + 'input-$1'
+                          )
+                        ]
+                      }),
+                      copy(element, {
+                        props: [replace(value, /:(plac\w+)/, ':' + MOZ + '$1')]
+                      }),
+                      copy(element, {
+                        props: [replace(value, /:(plac\w+)/, MS + 'input-$1')]
+                      })
+                    ],
+                    callback
+                  )
+              }
+
+              return ''
+            })
+      }
+}