tailwindcss 0.0.0-insiders.ff2c25f → 0.0.0-internal.b2586d4e

package/src/lib/getModuleDependencies.js

@@ -1,39 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import resolve from 'resolve'
-import detective from 'detective'
-
-function createModule(file) {
-  const source = fs.readFileSync(file, 'utf-8')
-  const requires = detective(source)
-
-  return { file, requires }
-}
-
-export default function getModuleDependencies(entryFile) {
-  const rootModule = createModule(entryFile)
-  const modules = [rootModule]
-
-  // Iterate over the modules, even when new
-  // ones are being added
-  for (const mdl of modules) {
-    mdl.requires
-      .filter((dep) => {
-        // Only track local modules, not node_modules
-        return dep.startsWith('./') || dep.startsWith('../')
-      })
-      .forEach((dep) => {
-        try {
-          const basedir = path.dirname(mdl.file)
-          const depPath = resolve.sync(dep, { basedir })
-          const depModule = createModule(depPath)
-
-          modules.push(depModule)
-        } catch (_err) {
-          // eslint-disable-next-line no-empty
-        }
-      })
-  }
-
-  return modules
-}

package/src/lib/normalizeTailwindDirectives.js

@@ -1,84 +0,0 @@
-import log from '../util/log'
-
-export default function normalizeTailwindDirectives(root) {
-  let tailwindDirectives = new Set()
-  let layerDirectives = new Set()
-  let applyDirectives = new Set()
-
-  root.walkAtRules((atRule) => {
-    if (atRule.name === 'apply') {
-      applyDirectives.add(atRule)
-    }
-
-    if (atRule.name === 'import') {
-      if (atRule.params === '"tailwindcss/base"' || atRule.params === "'tailwindcss/base'") {
-        atRule.name = 'tailwind'
-        atRule.params = 'base'
-      } else if (
-        atRule.params === '"tailwindcss/components"' ||
-        atRule.params === "'tailwindcss/components'"
-      ) {
-        atRule.name = 'tailwind'
-        atRule.params = 'components'
-      } else if (
-        atRule.params === '"tailwindcss/utilities"' ||
-        atRule.params === "'tailwindcss/utilities'"
-      ) {
-        atRule.name = 'tailwind'
-        atRule.params = 'utilities'
-      } else if (
-        atRule.params === '"tailwindcss/screens"' ||
-        atRule.params === "'tailwindcss/screens'" ||
-        atRule.params === '"tailwindcss/variants"' ||
-        atRule.params === "'tailwindcss/variants'"
-      ) {
-        atRule.name = 'tailwind'
-        atRule.params = 'variants'
-      }
-    }
-
-    if (atRule.name === 'tailwind') {
-      if (atRule.params === 'screens') {
-        atRule.params = 'variants'
-      }
-      tailwindDirectives.add(atRule.params)
-    }
-
-    if (['layer', 'responsive', 'variants'].includes(atRule.name)) {
-      if (['responsive', 'variants'].includes(atRule.name)) {
-        log.warn(`${atRule.name}-at-rule-deprecated`, [
-          `The \`@${atRule.name}\` directive has been deprecated in Tailwind CSS v3.0.`,
-          `Use \`@layer utilities\` or \`@layer components\` instead.`,
-          'https://tailwindcss.com/docs/upgrade-guide#replace-variants-with-layer',
-        ])
-      }
-      layerDirectives.add(atRule)
-    }
-  })
-
-  if (
-    !tailwindDirectives.has('base') ||
-    !tailwindDirectives.has('components') ||
-    !tailwindDirectives.has('utilities')
-  ) {
-    for (let rule of layerDirectives) {
-      if (rule.name === 'layer' && ['base', 'components', 'utilities'].includes(rule.params)) {
-        if (!tailwindDirectives.has(rule.params)) {
-          throw rule.error(
-            `\`@layer ${rule.params}\` is used but no matching \`@tailwind ${rule.params}\` directive is present.`
-          )
-        }
-      } else if (rule.name === 'responsive') {
-        if (!tailwindDirectives.has('utilities')) {
-          throw rule.error('`@responsive` is used but `@tailwind utilities` is missing.')
-        }
-      } else if (rule.name === 'variants') {
-        if (!tailwindDirectives.has('utilities')) {
-          throw rule.error('`@variants` is used but `@tailwind utilities` is missing.')
-        }
-      }
-    }
-  }
-
-  return { tailwindDirectives, applyDirectives }
-}

package/src/lib/offsets.js

@@ -1,367 +0,0 @@
-// @ts-check
-
-import bigSign from '../util/bigSign'
-import { remapBitfield } from './remap-bitfield.js'
-
-/**
- * @typedef {'base' | 'defaults' | 'components' | 'utilities' | 'variants' | 'user'} Layer
- */
-
-/**
- * @typedef {object} VariantOption
- * @property {number} id An unique identifier to identify `matchVariant`
- * @property {function | undefined} sort The sort function
- * @property {string|null} value The value we want to compare
- * @property {string|null} modifier The modifier that was used (if any)
- * @property {bigint} variant The variant bitmask
- */
-
-/**
- * @typedef {object} RuleOffset
- * @property {Layer} layer The layer that this rule belongs to
- * @property {Layer} parentLayer The layer that this rule originally belonged to. Only different from layer if this is a variant.
- * @property {bigint} arbitrary 0n if false, 1n if true
- * @property {bigint} variants Dynamic size. 1 bit per registered variant. 0n means no variants
- * @property {bigint} parallelIndex Rule index for the parallel variant. 0 if not applicable.
- * @property {bigint} index Index of the rule / utility in it's given *parent* layer. Monotonically increasing.
- * @property {VariantOption[]} options Some information on how we can sort arbitrary variants
- */
-
-export class Offsets {
-  constructor() {
-    /**
-     * Offsets for the next rule in a given layer
-     *
-     * @type {Record<Layer, bigint>}
-     */
-    this.offsets = {
-      defaults: 0n,
-      base: 0n,
-      components: 0n,
-      utilities: 0n,
-      variants: 0n,
-      user: 0n,
-    }
-
-    /**
-     * Positions for a given layer
-     *
-     * @type {Record<Layer, bigint>}
-     */
-    this.layerPositions = {
-      defaults: 0n,
-      base: 1n,
-      components: 2n,
-      utilities: 3n,
-
-      // There isn't technically a "user" layer, but we need to give it a position
-      // Because it's used for ordering user-css from @apply
-      user: 4n,
-
-      variants: 5n,
-    }
-
-    /**
-     * The total number of functions currently registered across all variants (including arbitrary variants)
-     *
-     * @type {bigint}
-     */
-    this.reservedVariantBits = 0n
-
-    /**
-     * Positions for a given variant
-     *
-     * @type {Map<string, bigint>}
-     */
-    this.variantOffsets = new Map()
-  }
-
-  /**
-   * @param {Layer} layer
-   * @returns {RuleOffset}
-   */
-  create(layer) {
-    return {
-      layer,
-      parentLayer: layer,
-      arbitrary: 0n,
-      variants: 0n,
-      parallelIndex: 0n,
-      index: this.offsets[layer]++,
-      options: [],
-    }
-  }
-
-  /**
-   * @returns {RuleOffset}
-   */
-  arbitraryProperty() {
-    return {
-      ...this.create('utilities'),
-      arbitrary: 1n,
-    }
-  }
-
-  /**
-   * Get the offset for a variant
-   *
-   * @param {string} variant
-   * @param {number} index
-   * @returns {RuleOffset}
-   */
-  forVariant(variant, index = 0) {
-    let offset = this.variantOffsets.get(variant)
-    if (offset === undefined) {
-      throw new Error(`Cannot find offset for unknown variant ${variant}`)
-    }
-
-    return {
-      ...this.create('variants'),
-      variants: offset << BigInt(index),
-    }
-  }
-
-  /**
-   * @param {RuleOffset} rule
-   * @param {RuleOffset} variant
-   * @param {VariantOption} options
-   * @returns {RuleOffset}
-   */
-  applyVariantOffset(rule, variant, options) {
-    options.variant = variant.variants
-
-    return {
-      ...rule,
-      layer: 'variants',
-      parentLayer: rule.layer === 'variants' ? rule.parentLayer : rule.layer,
-      variants: rule.variants | variant.variants,
-      options: options.sort ? [].concat(options, rule.options) : rule.options,
-
-      // TODO: Technically this is wrong. We should be handling parallel index on a per variant basis.
-      // We'll take the max of all the parallel indexes for now.
-      // @ts-ignore
-      parallelIndex: max([rule.parallelIndex, variant.parallelIndex]),
-    }
-  }
-
-  /**
-   * @param {RuleOffset} offset
-   * @param {number} parallelIndex
-   * @returns {RuleOffset}
-   */
-  applyParallelOffset(offset, parallelIndex) {
-    return {
-      ...offset,
-      parallelIndex: BigInt(parallelIndex),
-    }
-  }
-
-  /**
-   * Each variant gets 1 bit per function / rule registered.
-   * This is because multiple variants can be applied to a single rule and we need to know which ones are present and which ones are not.
-   * Additionally, every unique group of variants is grouped together in the stylesheet.
-   *
-   * This grouping is order-independent. For instance, we do not differentiate between `hover:focus` and `focus:hover`.
-   *
-   * @param {string[]} variants
-   * @param {(name: string) => number} getLength
-   */
-  recordVariants(variants, getLength) {
-    for (let variant of variants) {
-      this.recordVariant(variant, getLength(variant))
-    }
-  }
-
-  /**
-   * The same as `recordVariants` but for a single arbitrary variant at runtime.
-   * @param {string} variant
-   * @param {number} fnCount
-   *
-   * @returns {RuleOffset} The highest offset for this variant
-   */
-  recordVariant(variant, fnCount = 1) {
-    this.variantOffsets.set(variant, 1n << this.reservedVariantBits)
-
-    // Ensure space is reserved for each "function" in the parallel variant
-    // by offsetting the next variant by the number of parallel variants
-    // in the one we just added.
-
-    // Single functions that return parallel variants are NOT handled separately here
-    // They're offset by 1 (or the number of functions) as usual
-    // And each rule returned is tracked separately since the functions are evaluated lazily.
-    // @see `RuleOffset.parallelIndex`
-    this.reservedVariantBits += BigInt(fnCount)
-
-    return {
-      ...this.create('variants'),
-      variants: this.variantOffsets.get(variant),
-    }
-  }
-
-  /**
-   * @param {RuleOffset} a
-   * @param {RuleOffset} b
-   * @returns {bigint}
-   */
-  compare(a, b) {
-    // Sort layers together
-    if (a.layer !== b.layer) {
-      return this.layerPositions[a.layer] - this.layerPositions[b.layer]
-    }
-
-    // Sort based on the sorting function
-    for (let aOptions of a.options) {
-      for (let bOptions of b.options) {
-        if (aOptions.id !== bOptions.id) continue
-        if (!aOptions.sort || !bOptions.sort) continue
-
-        let maxFnVariant = max([aOptions.variant, bOptions.variant]) ?? 0n
-
-        // Create a mask of 0s from bits 1..N where N represents the mask of the Nth bit
-        let mask = ~(maxFnVariant | (maxFnVariant - 1n))
-        let aVariantsAfterFn = a.variants & mask
-        let bVariantsAfterFn = b.variants & mask
-
-        // If the variants the same, we _can_ sort them
-        if (aVariantsAfterFn !== bVariantsAfterFn) {
-          continue
-        }
-
-        let result = aOptions.sort(
-          {
-            value: aOptions.value,
-            modifier: aOptions.modifier,
-          },
-          {
-            value: bOptions.value,
-            modifier: bOptions.modifier,
-          }
-        )
-        if (result !== 0) return result
-      }
-    }
-
-    // Sort variants in the order they were registered
-    if (a.variants !== b.variants) {
-      return a.variants - b.variants
-    }
-
-    // Make sure each rule returned by a parallel variant is sorted in ascending order
-    if (a.parallelIndex !== b.parallelIndex) {
-      return a.parallelIndex - b.parallelIndex
-    }
-
-    // Always sort arbitrary properties after other utilities
-    if (a.arbitrary !== b.arbitrary) {
-      return a.arbitrary - b.arbitrary
-    }
-
-    // Sort utilities, components, etc… in the order they were registered
-    return a.index - b.index
-  }
-
-  /**
-   * Arbitrary variants are recorded in the order they're encountered.
-   * This means that the order is not stable between environments and sets of content files.
-   *
-   * In order to make the order stable, we need to remap the arbitrary variant offsets to
-   * be in alphabetical order starting from the offset of the first arbitrary variant.
-   */
-  recalculateVariantOffsets() {
-    // Sort the variants by their name
-    let variants = Array.from(this.variantOffsets.entries())
-      .filter(([v]) => v.startsWith('['))
-      .sort(([a], [z]) => fastCompare(a, z))
-
-    // Sort the list of offsets
-    // This is not necessarily a discrete range of numbers which is why
-    // we're using sort instead of creating a range from min/max
-    let newOffsets = variants.map(([, offset]) => offset).sort((a, z) => bigSign(a - z))
-
-    // Create a map from the old offsets to the new offsets in the new sort order
-    /** @type {[bigint, bigint][]} */
-    let mapping = variants.map(([, oldOffset], i) => [oldOffset, newOffsets[i]])
-
-    // Remove any variants that will not move letting us skip
-    // remapping if everything happens to be in order
-    return mapping.filter(([a, z]) => a !== z)
-  }
-
-  /**
-   * @template T
-   * @param {[RuleOffset, T][]} list
-   * @returns {[RuleOffset, T][]}
-   */
-  remapArbitraryVariantOffsets(list) {
-    let mapping = this.recalculateVariantOffsets()
-
-    // No arbitrary variants? Nothing to do.
-    // Everyhing already in order? Nothing to do.
-    if (mapping.length === 0) {
-      return list
-    }
-
-    // Remap every variant offset in the list
-    return list.map((item) => {
-      let [offset, rule] = item
-
-      offset = {
-        ...offset,
-        variants: remapBitfield(offset.variants, mapping),
-      }
-
-      return [offset, rule]
-    })
-  }
-
-  /**
-   * @template T
-   * @param {[RuleOffset, T][]} list
-   * @returns {[RuleOffset, T][]}
-   */
-  sort(list) {
-    list = this.remapArbitraryVariantOffsets(list)
-
-    return list.sort(([a], [b]) => bigSign(this.compare(a, b)))
-  }
-}
-
-/**
- *
- * @param {bigint[]} nums
- * @returns {bigint|null}
- */
-function max(nums) {
-  let max = null
-
-  for (const num of nums) {
-    max = max ?? num
-    max = max > num ? max : num
-  }
-
-  return max
-}
-
-/**
- * A fast ASCII order string comparison function.
- *
- * Using `.sort()` without a custom compare function is faster
- * But you can only use that if you're sorting an array of
- * only strings. If you're sorting strings inside objects
- * or arrays, you need must use a custom compare function.
- *
- * @param {string} a
- * @param {string} b
- */
-function fastCompare(a, b) {
-  let aLen = a.length
-  let bLen = b.length
-  let minLen = aLen < bLen ? aLen : bLen
-
-  for (let i = 0; i < minLen; i++) {
-    let cmp = a.charCodeAt(i) - b.charCodeAt(i)
-    if (cmp !== 0) return cmp
-  }
-
-  return aLen - bLen
-}

package/src/lib/partitionApplyAtRules.js

@@ -1,52 +0,0 @@
-function partitionRules(root) {
-  if (!root.walkAtRules) return
-
-  let applyParents = new Set()
-
-  root.walkAtRules('apply', (rule) => {
-    applyParents.add(rule.parent)
-  })
-
-  if (applyParents.size === 0) {
-    return
-  }
-
-  for (let rule of applyParents) {
-    let nodeGroups = []
-    let lastGroup = []
-
-    for (let node of rule.nodes) {
-      if (node.type === 'atrule' && node.name === 'apply') {
-        if (lastGroup.length > 0) {
-          nodeGroups.push(lastGroup)
-          lastGroup = []
-        }
-        nodeGroups.push([node])
-      } else {
-        lastGroup.push(node)
-      }
-    }
-
-    if (lastGroup.length > 0) {
-      nodeGroups.push(lastGroup)
-    }
-
-    if (nodeGroups.length === 1) {
-      continue
-    }
-
-    for (let group of [...nodeGroups].reverse()) {
-      let clone = rule.clone({ nodes: [] })
-      clone.append(group)
-      rule.after(clone)
-    }
-
-    rule.remove()
-  }
-}
-
-export default function expandApplyAtRules() {
-  return (root) => {
-    partitionRules(root)
-  }
-}

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
-}