vaderjs 1.1.1 → 1.1.2

package/website/node_modules/tailwindcss/src/util/resolveConfig.js

@@ -0,0 +1,277 @@
+import negateValue from './negateValue'
+import corePluginList from '../corePluginList'
+import configurePlugins from './configurePlugins'
+import colors from '../public/colors'
+import { defaults } from './defaults'
+import { toPath } from './toPath'
+import { normalizeConfig } from './normalizeConfig'
+import isPlainObject from './isPlainObject'
+import { cloneDeep } from './cloneDeep'
+import { parseColorFormat } from './pluginUtils'
+import { withAlphaValue } from './withAlphaVariable'
+import toColorValue from './toColorValue'
+
+function isFunction(input) {
+  return typeof input === 'function'
+}
+
+function mergeWith(target, ...sources) {
+  let customizer = sources.pop()
+
+  for (let source of sources) {
+    for (let k in source) {
+      let merged = customizer(target[k], source[k])
+
+      if (merged === undefined) {
+        if (isPlainObject(target[k]) && isPlainObject(source[k])) {
+          target[k] = mergeWith({}, target[k], source[k], customizer)
+        } else {
+          target[k] = source[k]
+        }
+      } else {
+        target[k] = merged
+      }
+    }
+  }
+
+  return target
+}
+
+const configUtils = {
+  colors,
+  negative(scale) {
+    // TODO: Log that this function isn't really needed anymore?
+    return Object.keys(scale)
+      .filter((key) => scale[key] !== '0')
+      .reduce((negativeScale, key) => {
+        let negativeValue = negateValue(scale[key])
+
+        if (negativeValue !== undefined) {
+          negativeScale[`-${key}`] = negativeValue
+        }
+
+        return negativeScale
+      }, {})
+  },
+  breakpoints(screens) {
+    return Object.keys(screens)
+      .filter((key) => typeof screens[key] === 'string')
+      .reduce(
+        (breakpoints, key) => ({
+          ...breakpoints,
+          [`screen-${key}`]: screens[key],
+        }),
+        {}
+      )
+  },
+}
+
+function value(valueToResolve, ...args) {
+  return isFunction(valueToResolve) ? valueToResolve(...args) : valueToResolve
+}
+
+function collectExtends(items) {
+  return items.reduce((merged, { extend }) => {
+    return mergeWith(merged, extend, (mergedValue, extendValue) => {
+      if (mergedValue === undefined) {
+        return [extendValue]
+      }
+
+      if (Array.isArray(mergedValue)) {
+        return [extendValue, ...mergedValue]
+      }
+
+      return [extendValue, mergedValue]
+    })
+  }, {})
+}
+
+function mergeThemes(themes) {
+  return {
+    ...themes.reduce((merged, theme) => defaults(merged, theme), {}),
+
+    // In order to resolve n config objects, we combine all of their `extend` properties
+    // into arrays instead of objects so they aren't overridden.
+    extend: collectExtends(themes),
+  }
+}
+
+function mergeExtensionCustomizer(merged, value) {
+  // When we have an array of objects, we do want to merge it
+  if (Array.isArray(merged) && isPlainObject(merged[0])) {
+    return merged.concat(value)
+  }
+
+  // When the incoming value is an array, and the existing config is an object, prepend the existing object
+  if (Array.isArray(value) && isPlainObject(value[0]) && isPlainObject(merged)) {
+    return [merged, ...value]
+  }
+
+  // Override arrays (for example for font-families, box-shadows, ...)
+  if (Array.isArray(value)) {
+    return value
+  }
+
+  // Execute default behaviour
+  return undefined
+}
+
+function mergeExtensions({ extend, ...theme }) {
+  return mergeWith(theme, extend, (themeValue, extensions) => {
+    // The `extend` property is an array, so we need to check if it contains any functions
+    if (!isFunction(themeValue) && !extensions.some(isFunction)) {
+      return mergeWith({}, themeValue, ...extensions, mergeExtensionCustomizer)
+    }
+
+    return (resolveThemePath, utils) =>
+      mergeWith(
+        {},
+        ...[themeValue, ...extensions].map((e) => value(e, resolveThemePath, utils)),
+        mergeExtensionCustomizer
+      )
+  })
+}
+
+/**
+ *
+ * @param {string} key
+ * @return {Iterable<string[] & {alpha: string | undefined}>}
+ */
+function* toPaths(key) {
+  let path = toPath(key)
+
+  if (path.length === 0) {
+    return
+  }
+
+  yield path
+
+  if (Array.isArray(key)) {
+    return
+  }
+
+  let pattern = /^(.*?)\s*\/\s*([^/]+)$/
+  let matches = key.match(pattern)
+
+  if (matches !== null) {
+    let [, prefix, alpha] = matches
+
+    let newPath = toPath(prefix)
+    newPath.alpha = alpha
+
+    yield newPath
+  }
+}
+
+function resolveFunctionKeys(object) {
+  // theme('colors.red.500 / 0.5') -> ['colors', 'red', '500 / 0', '5]
+
+  const resolvePath = (key, defaultValue) => {
+    for (const path of toPaths(key)) {
+      let index = 0
+      let val = object
+
+      while (val !== undefined && val !== null && index < path.length) {
+        val = val[path[index++]]
+
+        let shouldResolveAsFn =
+          isFunction(val) && (path.alpha === undefined || index <= path.length - 1)
+
+        val = shouldResolveAsFn ? val(resolvePath, configUtils) : val
+      }
+
+      if (val !== undefined) {
+        if (path.alpha !== undefined) {
+          let normalized = parseColorFormat(val)
+
+          return withAlphaValue(normalized, path.alpha, toColorValue(normalized))
+        }
+
+        if (isPlainObject(val)) {
+          return cloneDeep(val)
+        }
+
+        return val
+      }
+    }
+
+    return defaultValue
+  }
+
+  Object.assign(resolvePath, {
+    theme: resolvePath,
+    ...configUtils,
+  })
+
+  return Object.keys(object).reduce((resolved, key) => {
+    resolved[key] = isFunction(object[key]) ? object[key](resolvePath, configUtils) : object[key]
+
+    return resolved
+  }, {})
+}
+
+function extractPluginConfigs(configs) {
+  let allConfigs = []
+
+  configs.forEach((config) => {
+    allConfigs = [...allConfigs, config]
+
+    const plugins = config?.plugins ?? []
+
+    if (plugins.length === 0) {
+      return
+    }
+
+    plugins.forEach((plugin) => {
+      if (plugin.__isOptionsFunction) {
+        plugin = plugin()
+      }
+      allConfigs = [...allConfigs, ...extractPluginConfigs([plugin?.config ?? {}])]
+    })
+  })
+
+  return allConfigs
+}
+
+function resolveCorePlugins(corePluginConfigs) {
+  const result = [...corePluginConfigs].reduceRight((resolved, corePluginConfig) => {
+    if (isFunction(corePluginConfig)) {
+      return corePluginConfig({ corePlugins: resolved })
+    }
+    return configurePlugins(corePluginConfig, resolved)
+  }, corePluginList)
+
+  return result
+}
+
+function resolvePluginLists(pluginLists) {
+  const result = [...pluginLists].reduceRight((resolved, pluginList) => {
+    return [...resolved, ...pluginList]
+  }, [])
+
+  return result
+}
+
+export default function resolveConfig(configs) {
+  let allConfigs = [
+    ...extractPluginConfigs(configs),
+    {
+      prefix: '',
+      important: false,
+      separator: ':',
+    },
+  ]
+
+  return normalizeConfig(
+    defaults(
+      {
+        theme: resolveFunctionKeys(
+          mergeExtensions(mergeThemes(allConfigs.map((t) => t?.theme ?? {})))
+        ),
+        corePlugins: resolveCorePlugins(allConfigs.map((c) => c.corePlugins)),
+        plugins: resolvePluginLists(configs.map((c) => c?.plugins ?? [])),
+      },
+      ...allConfigs
+    )
+  )
+}

package/website/node_modules/tailwindcss/src/util/resolveConfigPath.js

@@ -0,0 +1,66 @@
+import fs from 'fs'
+import path from 'path'
+
+const defaultConfigFiles = [
+  './tailwind.config.js',
+  './tailwind.config.cjs',
+  './tailwind.config.mjs',
+  './tailwind.config.ts',
+]
+
+function isObject(value) {
+  return typeof value === 'object' && value !== null
+}
+
+function isEmpty(obj) {
+  return Object.keys(obj).length === 0
+}
+
+function isString(value) {
+  return typeof value === 'string' || value instanceof String
+}
+
+export default function resolveConfigPath(pathOrConfig) {
+  // require('tailwindcss')({ theme: ..., variants: ... })
+  if (isObject(pathOrConfig) && pathOrConfig.config === undefined && !isEmpty(pathOrConfig)) {
+    return null
+  }
+
+  // require('tailwindcss')({ config: 'custom-config.js' })
+  if (
+    isObject(pathOrConfig) &&
+    pathOrConfig.config !== undefined &&
+    isString(pathOrConfig.config)
+  ) {
+    return path.resolve(pathOrConfig.config)
+  }
+
+  // require('tailwindcss')({ config: { theme: ..., variants: ... } })
+  if (
+    isObject(pathOrConfig) &&
+    pathOrConfig.config !== undefined &&
+    isObject(pathOrConfig.config)
+  ) {
+    return null
+  }
+
+  // require('tailwindcss')('custom-config.js')
+  if (isString(pathOrConfig)) {
+    return path.resolve(pathOrConfig)
+  }
+
+  // require('tailwindcss')
+  return resolveDefaultConfigPath()
+}
+
+export function resolveDefaultConfigPath() {
+  for (const configFile of defaultConfigFiles) {
+    try {
+      const configPath = path.resolve(configFile)
+      fs.accessSync(configPath)
+      return configPath
+    } catch (err) {}
+  }
+
+  return null
+}

package/website/node_modules/tailwindcss/src/util/responsive.js

@@ -0,0 +1,10 @@
+import postcss from 'postcss'
+import cloneNodes from './cloneNodes'
+
+export default function responsive(rules) {
+  return postcss
+    .atRule({
+      name: 'responsive',
+    })
+    .append(cloneNodes(Array.isArray(rules) ? rules : [rules]))
+}

package/website/node_modules/tailwindcss/src/util/splitAtTopLevelOnly.js

@@ -0,0 +1,52 @@
+/**
+ * This splits a string on a top-level character.
+ *
+ * Regex doesn't support recursion (at least not the JS-flavored version).
+ * So we have to use a tiny state machine to keep track of paren placement.
+ *
+ * Expected behavior using commas:
+ * var(--a, 0 0 1px rgb(0, 0, 0)), 0 0 1px rgb(0, 0, 0)
+ *       ─┬─             ┬  ┬    ┬
+ *        x              x  x    ╰──────── Split because top-level
+ *        ╰──────────────┴──┴───────────── Ignored b/c inside >= 1 levels of parens
+ *
+ * @param {string} input
+ * @param {string} separator
+ */
+export function splitAtTopLevelOnly(input, separator) {
+  let stack = []
+  let parts = []
+  let lastPos = 0
+  let isEscaped = false
+
+  for (let idx = 0; idx < input.length; idx++) {
+    let char = input[idx]
+
+    if (stack.length === 0 && char === separator[0] && !isEscaped) {
+      if (separator.length === 1 || input.slice(idx, idx + separator.length) === separator) {
+        parts.push(input.slice(lastPos, idx))
+        lastPos = idx + separator.length
+      }
+    }
+
+    if (isEscaped) {
+      isEscaped = false
+    } else if (char === '\\') {
+      isEscaped = true
+    }
+
+    if (char === '(' || char === '[' || char === '{') {
+      stack.push(char)
+    } else if (
+      (char === ')' && stack[stack.length - 1] === '(') ||
+      (char === ']' && stack[stack.length - 1] === '[') ||
+      (char === '}' && stack[stack.length - 1] === '{')
+    ) {
+      stack.pop()
+    }
+  }
+
+  parts.push(input.slice(lastPos))
+
+  return parts
+}

package/website/node_modules/tailwindcss/src/util/tap.js

@@ -0,0 +1,4 @@
+export function tap(value, mutator) {
+  mutator(value)
+  return value
+}

package/website/node_modules/tailwindcss/src/util/toColorValue.js

@@ -0,0 +1,3 @@
+export default function toColorValue(maybeFunction) {
+  return typeof maybeFunction === 'function' ? maybeFunction({}) : maybeFunction
+}

package/website/node_modules/tailwindcss/src/util/toPath.js

@@ -0,0 +1,26 @@
+/**
+ * Parse a path string into an array of path segments.
+ *
+ * Square bracket notation `a[b]` may be used to "escape" dots that would otherwise be interpreted as path separators.
+ *
+ * Example:
+ * a -> ['a']
+ * a.b.c -> ['a', 'b', 'c']
+ * a[b].c -> ['a', 'b', 'c']
+ * a[b.c].e.f -> ['a', 'b.c', 'e', 'f']
+ * a[b][c][d] -> ['a', 'b', 'c', 'd']
+ *
+ * @param {string|string[]} path
+ **/
+export function toPath(path) {
+  if (Array.isArray(path)) return path
+
+  let openBrackets = path.split('[').length - 1
+  let closedBrackets = path.split(']').length - 1
+
+  if (openBrackets !== closedBrackets) {
+    throw new Error(`Path is invalid. Has unbalanced brackets: ${path}`)
+  }
+
+  return path.split(/\.(?![^\[]*\])|[\[\]]/g).filter(Boolean)
+}

package/website/node_modules/tailwindcss/src/util/transformThemeValue.js

@@ -0,0 +1,62 @@
+import postcss from 'postcss'
+import isPlainObject from './isPlainObject'
+
+export default function transformThemeValue(themeSection) {
+  if (['fontSize', 'outline'].includes(themeSection)) {
+    return (value) => {
+      if (typeof value === 'function') value = value({})
+      if (Array.isArray(value)) value = value[0]
+
+      return value
+    }
+  }
+
+  if (themeSection === 'fontFamily') {
+    return (value) => {
+      if (typeof value === 'function') value = value({})
+      let families = Array.isArray(value) && isPlainObject(value[1]) ? value[0] : value
+      return Array.isArray(families) ? families.join(', ') : families
+    }
+  }
+
+  if (
+    [
+      'boxShadow',
+      'transitionProperty',
+      'transitionDuration',
+      'transitionDelay',
+      'transitionTimingFunction',
+      'backgroundImage',
+      'backgroundSize',
+      'backgroundColor',
+      'cursor',
+      'animation',
+    ].includes(themeSection)
+  ) {
+    return (value) => {
+      if (typeof value === 'function') value = value({})
+      if (Array.isArray(value)) value = value.join(', ')
+
+      return value
+    }
+  }
+
+  // For backwards compatibility reasons, before we switched to underscores
+  // instead of commas for arbitrary values.
+  if (['gridTemplateColumns', 'gridTemplateRows', 'objectPosition'].includes(themeSection)) {
+    return (value) => {
+      if (typeof value === 'function') value = value({})
+      if (typeof value === 'string') value = postcss.list.comma(value).join(' ')
+
+      return value
+    }
+  }
+
+  return (value, opts = {}) => {
+    if (typeof value === 'function') {
+      value = value(opts)
+    }
+
+    return value
+  }
+}

package/website/node_modules/tailwindcss/src/util/validateConfig.js

@@ -0,0 +1,26 @@
+import log from './log'
+
+export function validateConfig(config) {
+  if (config.content.files.length === 0) {
+    log.warn('content-problems', [
+      'The `content` option in your Tailwind CSS configuration is missing or empty.',
+      'Configure your content sources or your generated CSS will be missing styles.',
+      'https://tailwindcss.com/docs/content-configuration',
+    ])
+  }
+
+  // Warn if the line-clamp plugin is installed
+  try {
+    let plugin = require('@tailwindcss/line-clamp')
+    if (config.plugins.includes(plugin)) {
+      log.warn('line-clamp-in-core', [
+        'As of Tailwind CSS v3.3, the `@tailwindcss/line-clamp` plugin is now included by default.',
+        'Remove it from the `plugins` array in your configuration to eliminate this warning.',
+      ])
+
+      config.plugins = config.plugins.filter((p) => p !== plugin)
+    }
+  } catch {}
+
+  return config
+}

package/website/node_modules/tailwindcss/src/util/validateFormalSyntax.js

@@ -0,0 +1,34 @@
+import { length, percentage } from './dataTypes'
+import { splitAtTopLevelOnly } from './splitAtTopLevelOnly'
+
+/**
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/background-size#formal_syntax
+ *
+ * background-size =
+ *  <bg-size>#
+ *
+ * <bg-size> =
+ *   [ <length-percentage [0,∞]> | auto ]{1,2}  |
+ *   cover                                      |
+ *   contain
+ *
+ * <length-percentage> =
+ *   <length>      |
+ *   <percentage>
+ *
+ * @param {string} value
+ */
+export function backgroundSize(value) {
+  let keywordValues = ['cover', 'contain']
+  // the <length-percentage> type will probably be a css function
+  // so we have to use `splitAtTopLevelOnly`
+  return splitAtTopLevelOnly(value, ',').every((part) => {
+    let sizes = splitAtTopLevelOnly(part, '_').filter(Boolean)
+    if (sizes.length === 1 && keywordValues.includes(sizes[0])) return true
+
+    if (sizes.length !== 1 && sizes.length !== 2) return false
+
+    return sizes.every((size) => length(size) || percentage(size) || size === 'auto')
+  })
+}

package/website/node_modules/tailwindcss/src/util/withAlphaVariable.js

@@ -0,0 +1,49 @@
+import { parseColor, formatColor } from './color'
+
+export function withAlphaValue(color, alphaValue, defaultValue) {
+  if (typeof color === 'function') {
+    return color({ opacityValue: alphaValue })
+  }
+
+  let parsed = parseColor(color, { loose: true })
+
+  if (parsed === null) {
+    return defaultValue
+  }
+
+  return formatColor({ ...parsed, alpha: alphaValue })
+}
+
+export default function withAlphaVariable({ color, property, variable }) {
+  let properties = [].concat(property)
+  if (typeof color === 'function') {
+    return {
+      [variable]: '1',
+      ...Object.fromEntries(
+        properties.map((p) => {
+          return [p, color({ opacityVariable: variable, opacityValue: `var(${variable})` })]
+        })
+      ),
+    }
+  }
+
+  const parsed = parseColor(color)
+
+  if (parsed === null) {
+    return Object.fromEntries(properties.map((p) => [p, color]))
+  }
+
+  if (parsed.alpha !== undefined) {
+    // Has an alpha value, return color as-is
+    return Object.fromEntries(properties.map((p) => [p, color]))
+  }
+
+  return {
+    [variable]: '1',
+    ...Object.fromEntries(
+      properties.map((p) => {
+        return [p, formatColor({ ...parsed, alpha: `var(${variable})` })]
+      })
+    ),
+  }
+}

package/website/node_modules/tailwindcss/src/value-parser/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) Bogdan Chadkin <trysound@yandex.ru>
+
+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/website/node_modules/tailwindcss/src/value-parser/README.md

@@ -0,0 +1,3 @@
+# postcss-value-parser (forked + inlined)
+
+This is a customized version of of [PostCSS Value Parser](https://github.com/TrySound/postcss-value-parser) to fix some bugs around parsing CSS functions.