tailwindcss 0.0.0-insiders.de00a62 → 0.0.0-insiders.deb33a9

package/src/lib/regex.js

@@ -1,74 +0,0 @@
-const REGEX_SPECIAL = /[\\^$.*+?()[\]{}|]/g
-const REGEX_HAS_SPECIAL = RegExp(REGEX_SPECIAL.source)
-
-/**
- * @param {string|RegExp|Array<string|RegExp>} source
- */
-function toSource(source) {
-  source = Array.isArray(source) ? source : [source]
-
-  source = source.map((item) => (item instanceof RegExp ? item.source : item))
-
-  return source.join('')
-}
-
-/**
- * @param {string|RegExp|Array<string|RegExp>} source
- */
-export function pattern(source) {
-  return new RegExp(toSource(source), 'g')
-}
-
-/**
- * @param {string|RegExp|Array<string|RegExp>} source
- */
-export function withoutCapturing(source) {
-  return new RegExp(`(?:${toSource(source)})`, 'g')
-}
-
-/**
- * @param {Array<string|RegExp>} sources
- */
-export function any(sources) {
-  return `(?:${sources.map(toSource).join('|')})`
-}
-
-/**
- * @param {string|RegExp} source
- */
-export function optional(source) {
-  return `(?:${toSource(source)})?`
-}
-
-/**
- * @param {string|RegExp|Array<string|RegExp>} source
- */
-export function zeroOrMore(source) {
-  return `(?:${toSource(source)})*`
-}
-
-/**
- * Generate a RegExp that matches balanced brackets for a given depth
- * We have to specify a depth because JS doesn't support recursive groups using ?R
- *
- * Based on https://stackoverflow.com/questions/17759004/how-to-match-string-within-parentheses-nested-in-java/17759264#17759264
- *
- * @param {string|RegExp|Array<string|RegExp>} source
- */
-export function nestedBrackets(open, close, depth = 1) {
-  return withoutCapturing([
-    escape(open),
-    /[^\s]*/,
-    depth === 1
-      ? `[^${escape(open)}${escape(close)}\s]*`
-      : any([`[^${escape(open)}${escape(close)}\s]*`, nestedBrackets(open, close, depth - 1)]),
-    /[^\s]*/,
-    escape(close),
-  ])
-}
-
-export function escape(string) {
-  return string && REGEX_HAS_SPECIAL.test(string)
-    ? string.replace(REGEX_SPECIAL, '\\$&')
-    : string || ''
-}

package/src/lib/remap-bitfield.js

@@ -1,82 +0,0 @@
-// @ts-check
-
-/**
- * We must remap all the old bits to new bits for each set variant
- * Only arbitrary variants are considered as those are the only
- * ones that need to be re-sorted at this time
- *
- * An iterated process that removes and sets individual bits simultaneously
- * will not work because we may have a new bit that is also a later old bit
- * This means that we would be removing a previously set bit which we don't
- * want to do
- *
- * For example (assume `bN` = `1<<N`)
- * Given the "total" mapping `[[b1, b3], [b2, b4], [b3, b1], [b4, b2]]`
- * The mapping is "total" because:
- * 1. Every input and output is accounted for
- * 2. All combinations are unique
- * 3. No one input maps to multiple outputs and vice versa
- * And, given an offset with all bits set:
- * V = b1 | b2 | b3 | b4
- *
- * Let's explore the issue with removing and setting bits simultaneously:
- * V & ~b1 | b3 = b2 | b3 | b4
- * V & ~b2 | b4 = b3 | b4
- * V & ~b3 | b1 = b1 | b4
- * V & ~b4 | b2 = b1 | b2
- *
- * As you can see, we end up with the wrong result.
- * This is because we're removing a bit that was previously set.
- * And, thus the final result is missing b3 and b4.
- *
- * Now, let's explore the issue with removing the bits first:
- * V & ~b1 = b2 | b3 | b4
- * V & ~b2 = b3 | b4
- * V & ~b3 = b4
- * V & ~b4 = 0
- *
- * And then setting the bits:
- * V | b3 = b3
- * V | b4 = b3 | b4
- * V | b1 = b1 | b3 | b4
- * V | b2 = b1 | b2 | b3 | b4
- *
- * We get the correct result because we're not removing any bits that were
- * previously set thus properly remapping the bits to the new order
- *
- * To collect this into a single operation that can be done simultaneously
- * we must first create a mask for the old bits that are set and a mask for
- * the new bits that are set. Then we can remove the old bits and set the new
- * bits simultaneously in a "single" operation like so:
- * OldMask = b1 | b2 | b3 | b4
- * NewMask = b3 | b4 | b1 | b2
- *
- * So this:
- * V & ~oldMask | newMask
- *
- * Expands to this:
- * V & ~b1 & ~b2 & ~b3 & ~b4 | b3 | b4 | b1 | b2
- *
- * Which becomes this:
- * b1 | b2 | b3 | b4
- *
- * Which is the correct result!
- *
- * @param {bigint} num
- * @param {[bigint, bigint][]} mapping
- */
-export function remapBitfield(num, mapping) {
-  // Create masks for the old and new bits that are set
-  let oldMask = 0n
-  let newMask = 0n
-  for (let [oldBit, newBit] of mapping) {
-    if (num & oldBit) {
-      oldMask = oldMask | oldBit
-      newMask = newMask | newBit
-    }
-  }
-
-  // Remove all old bits
-  // Set all new bits
-  return (num & ~oldMask) | newMask
-}

package/src/lib/resolveDefaultsAtRules.js

@@ -1,167 +0,0 @@
-import postcss from 'postcss'
-import selectorParser from 'postcss-selector-parser'
-import { flagEnabled } from '../featureFlags'
-
-let getNode = {
-  id(node) {
-    return selectorParser.attribute({
-      attribute: 'id',
-      operator: '=',
-      value: node.value,
-      quoteMark: '"',
-    })
-  },
-}
-
-function minimumImpactSelector(nodes) {
-  let rest = nodes
-    .filter((node) => {
-      // Keep non-pseudo nodes
-      if (node.type !== 'pseudo') return true
-
-      // Keep pseudo nodes that have subnodes
-      // E.g.: `:not()` contains subnodes inside the parentheses
-      if (node.nodes.length > 0) return true
-
-      // Keep pseudo `elements`
-      // This implicitly means that we ignore pseudo `classes`
-      return (
-        node.value.startsWith('::') ||
-        [':before', ':after', ':first-line', ':first-letter'].includes(node.value)
-      )
-    })
-    .reverse()
-
-  let searchFor = new Set(['tag', 'class', 'id', 'attribute'])
-
-  let splitPointIdx = rest.findIndex((n) => searchFor.has(n.type))
-  if (splitPointIdx === -1) return rest.reverse().join('').trim()
-
-  let node = rest[splitPointIdx]
-  let bestNode = getNode[node.type] ? getNode[node.type](node) : node
-
-  rest = rest.slice(0, splitPointIdx)
-
-  let combinatorIdx = rest.findIndex((n) => n.type === 'combinator' && n.value === '>')
-  if (combinatorIdx !== -1) {
-    rest.splice(0, combinatorIdx)
-    rest.unshift(selectorParser.universal())
-  }
-
-  return [bestNode, ...rest.reverse()].join('').trim()
-}
-
-export let elementSelectorParser = selectorParser((selectors) => {
-  return selectors.map((s) => {
-    let nodes = s.split((n) => n.type === 'combinator' && n.value === ' ').pop()
-    return minimumImpactSelector(nodes)
-  })
-})
-
-let cache = new Map()
-
-function extractElementSelector(selector) {
-  if (!cache.has(selector)) {
-    cache.set(selector, elementSelectorParser.transformSync(selector))
-  }
-
-  return cache.get(selector)
-}
-
-export default function resolveDefaultsAtRules({ tailwindConfig }) {
-  return (root) => {
-    let variableNodeMap = new Map()
-
-    /** @type {Set<import('postcss').AtRule>} */
-    let universals = new Set()
-
-    root.walkAtRules('defaults', (rule) => {
-      if (rule.nodes && rule.nodes.length > 0) {
-        universals.add(rule)
-        return
-      }
-
-      let variable = rule.params
-      if (!variableNodeMap.has(variable)) {
-        variableNodeMap.set(variable, new Set())
-      }
-
-      variableNodeMap.get(variable).add(rule.parent)
-
-      rule.remove()
-    })
-
-    if (flagEnabled(tailwindConfig, 'optimizeUniversalDefaults')) {
-      for (let universal of universals) {
-        /** @type {Map<string, Set<string>>} */
-        let selectorGroups = new Map()
-
-        let rules = variableNodeMap.get(universal.params) ?? []
-
-        for (let rule of rules) {
-          for (let selector of extractElementSelector(rule.selector)) {
-            // If selector contains a vendor prefix after a pseudo element or class,
-            // we consider them separately because merging the declarations into
-            // a single rule will cause browsers that do not understand the
-            // vendor prefix to throw out the whole rule
-            // Additionally if a selector contains `:has` we also consider
-            // it separately because FF only recently gained support for it
-            let selectorGroupName =
-              selector.includes(':-') || selector.includes('::-') || selector.includes(':has')
-                ? selector
-                : '__DEFAULT__'
-
-            let selectors = selectorGroups.get(selectorGroupName) ?? new Set()
-            selectorGroups.set(selectorGroupName, selectors)
-
-            selectors.add(selector)
-          }
-        }
-
-        if (flagEnabled(tailwindConfig, 'optimizeUniversalDefaults')) {
-          if (selectorGroups.size === 0) {
-            universal.remove()
-            continue
-          }
-
-          for (let [, selectors] of selectorGroups) {
-            let universalRule = postcss.rule({
-              source: universal.source,
-            })
-
-            universalRule.selectors = [...selectors]
-
-            universalRule.append(universal.nodes.map((node) => node.clone()))
-            universal.before(universalRule)
-          }
-        }
-
-        universal.remove()
-      }
-    } else if (universals.size) {
-      let universalRule = postcss.rule({
-        selectors: ['*', '::before', '::after'],
-      })
-
-      for (let universal of universals) {
-        universalRule.append(universal.nodes)
-
-        if (!universalRule.parent) {
-          universal.before(universalRule)
-        }
-
-        if (!universalRule.source) {
-          universalRule.source = universal.source
-        }
-
-        universal.remove()
-      }
-
-      let backdropRule = universalRule.clone({
-        selectors: ['::backdrop'],
-      })
-
-      universalRule.after(backdropRule)
-    }
-  }
-}