FM / util

/opt/canhelp/node_modules/tailwindcss/src/util/

/opt/canhelp/node_modules/tailwindcss/src/util

Name	Size	Mode	Actions
applyImportantSelector.js	774	0644	edit dl rm
bigSign.js	98	0644	edit dl rm
buildMediaQuery.js	560	0644	edit dl rm
cloneDeep.js	283	0644	edit dl rm
cloneNodes.js	1333	0644	edit dl rm
color.js	2718	0644	edit dl rm
colorNames.js	4301	0644	edit dl rm
configurePlugins.js	578	0644	edit dl rm
createPlugin.js	703	0644	edit dl rm
createUtilityPlugin.js	1222	0644	edit dl rm
dataTypes.js	7332	0644	edit dl rm
defaults.js	361	0644	edit dl rm
escapeClassName.js	255	0644	edit dl rm
escapeCommas.js	96	0644	edit dl rm
flattenColorPalette.js	410	0644	edit dl rm
formatVariantSelector.js	9862	0644	edit dl rm
getAllConfigs.js	1037	0644	edit dl rm
hashConfig.js	126	0644	edit dl rm
isKeyframeRule.js	142	0644	edit dl rm
isPlainObject.js	262	0644	edit dl rm
isSyntacticallyValidPropertyValue.js	1612	0644	edit dl rm
log.js	789	0644	edit dl rm
math-operators.ts	5290	0644	edit dl rm
nameClass.js	634	0644	edit dl rm
negateValue.js	771	0644	edit dl rm
normalizeConfig.js	9024	0644	edit dl rm
normalizeScreens.js	4346	0644	edit dl rm
parseAnimationValue.js	2351	0644	edit dl rm
parseBoxShadowValue.js	1855	0644	edit dl rm
parseDependency.js	867	0644	edit dl rm
parseGlob.js	510	0644	edit dl rm
parseObjectStyles.js	429	0644	edit dl rm
pluginUtils.js	8183	0644	edit dl rm
prefixSelector.js	992	0644	edit dl rm
pseudoElements.js	5717	0644	edit dl rm
removeAlphaVariables.js	785	0644	edit dl rm
resolveConfig.js	6967	0644	edit dl rm
resolveConfigPath.js	1591	0644	edit dl rm
responsive.js	243	0644	edit dl rm
splitAtTopLevelOnly.js	1527	0644	edit dl rm
tap.js	72	0644	edit dl rm
toColorValue.js	137	0644	edit dl rm
toPath.js	739	0644	edit dl rm
transformThemeValue.js	1637	0644	edit dl rm
validateConfig.js	888	0644	edit dl rm
validateFormalSyntax.js	1020	0644	edit dl rm
withAlphaVariable.js	1215	0644	edit dl rm

Edit: /opt/canhelp/node_modules/tailwindcss/src/util/formatVariantSelector.js (9862B)

import selectorParser from 'postcss-selector-parser'
import unescape from 'postcss-selector-parser/dist/util/unesc'
import escapeClassName from '../util/escapeClassName'
import prefixSelector from '../util/prefixSelector'
import { movePseudos } from './pseudoElements'
import { splitAtTopLevelOnly } from './splitAtTopLevelOnly'

/** @typedef {import('postcss-selector-parser').Root} Root */
/** @typedef {import('postcss-selector-parser').Selector} Selector */
/** @typedef {import('postcss-selector-parser').Pseudo} Pseudo */
/** @typedef {import('postcss-selector-parser').Node} Node */

/** @typedef {{format: string, respectPrefix: boolean}[]} RawFormats */
/** @typedef {import('postcss-selector-parser').Root} ParsedFormats */
/** @typedef {RawFormats | ParsedFormats} AcceptedFormats */

let MERGE = ':merge'

/**
 * @param {RawFormats} formats
 * @param {{context: any, candidate: string, base: string | null}} options
 * @returns {ParsedFormats | null}
 */
export function formatVariantSelector(formats, { context, candidate }) {
  let prefix = context?.tailwindConfig.prefix ?? ''

// Parse the format selector into an AST
  let parsedFormats = formats.map((format) => {
    let ast = selectorParser().astSync(format.format)

return {
      ...format,
      ast: format.respectPrefix ? prefixSelector(prefix, ast) : ast,
    }
  })

// We start with the candidate selector
  let formatAst = selectorParser.root({
    nodes: [
      selectorParser.selector({
        nodes: [selectorParser.className({ value: escapeClassName(candidate) })],
      }),
    ],
  })

// And iteratively merge each format selector into the candidate selector
  for (let { ast } of parsedFormats) {
    // 1. Handle :merge() special pseudo-class
    ;[formatAst, ast] = handleMergePseudo(formatAst, ast)

// 2. Merge the format selector into the current selector AST
    ast.walkNesting((nesting) => nesting.replaceWith(...formatAst.nodes[0].nodes))

// 3. Keep going!
    formatAst = ast
  }

return formatAst
}

/**
 * Given any node in a selector this gets the "simple" selector it's a part of
 * A simple selector is just a list of nodes without any combinators
 * Technically :is(), :not(), :has(), etc… can have combinators but those are nested
 * inside the relevant node and won't be picked up so they're fine to ignore
 *
 * @param {Node} node
 * @returns {Node[]}
 **/
function simpleSelectorForNode(node) {
  /** @type {Node[]} */
  let nodes = []

// Walk backwards until we hit a combinator node (or the start)
  while (node.prev() && node.prev().type !== 'combinator') {
    node = node.prev()
  }

// Now record all non-combinator nodes until we hit one (or the end)
  while (node && node.type !== 'combinator') {
    nodes.push(node)
    node = node.next()
  }

return nodes
}

/**
 * Resorts the nodes in a selector to ensure they're in the correct order
 * Tags go before classes, and pseudo classes go after classes
 *
 * @param {Selector} sel
 * @returns {Selector}
 **/
function resortSelector(sel) {
  sel.sort((a, b) => {
    if (a.type === 'tag' && b.type === 'class') {
      return -1
    } else if (a.type === 'class' && b.type === 'tag') {
      return 1
    } else if (a.type === 'class' && b.type === 'pseudo' && b.value.startsWith('::')) {
      return -1
    } else if (a.type === 'pseudo' && a.value.startsWith('::') && b.type === 'class') {
      return 1
    }

return sel.index(a) - sel.index(b)
  })

return sel
}

/**
 * Remove extraneous selectors that do not include the base class/candidate
 *
 * Example:
 * Given the utility `.a, .b { color: red}`
 * Given the candidate `sm:b`
 *
 * The final selector should be `.sm\:b` and not `.a, .sm\:b`
 *
 * @param {Selector} ast
 * @param {string} base
 */
export function eliminateIrrelevantSelectors(sel, base) {
  let hasClassesMatchingCandidate = false

sel.walk((child) => {
    if (child.type === 'class' && child.value === base) {
      hasClassesMatchingCandidate = true
      return false // Stop walking
    }
  })

if (!hasClassesMatchingCandidate) {
    sel.remove()
  }

// We do NOT recursively eliminate sub selectors that don't have the base class
  // as this is NOT a safe operation. For example, if we have:
  // `.space-x-2 > :not([hidden]) ~ :not([hidden])`
  // We cannot remove the [hidden] from the :not() because it would change the
  // meaning of the selector.

// TODO: Can we do this for :matches, :is, and :where?
}

/**
 * @param {string} current
 * @param {AcceptedFormats} formats
 * @param {{context: any, candidate: string, base: string | null}} options
 * @returns {string}
 */
export function finalizeSelector(current, formats, { context, candidate, base }) {
  let separator = context?.tailwindConfig?.separator ?? ':'

// Split by the separator, but ignore the separator inside square brackets:
  //
  // E.g.: dark:lg:hover:[paint-order:markers]
  //           ┬  ┬     ┬            ┬
  //           │  │     │            ╰── We will not split here
  //           ╰──┴─────┴─────────────── We will split here
  //
  base = base ?? splitAtTopLevelOnly(candidate, separator).pop()

// Parse the selector into an AST
  let selector = selectorParser().astSync(current)

// Normalize escaped classes, e.g.:
  //
  // The idea would be to replace the escaped `base` in the selector with the
  // `format`. However, in css you can escape the same selector in a few
  // different ways. This would result in different strings and therefore we
  // can't replace it properly.
  //
  //               base: bg-[rgb(255,0,0)]
  //   base in selector: bg-\\[rgb\\(255\\,0\\,0\\)\\]
  //       escaped base: bg-\\[rgb\\(255\\2c 0\\2c 0\\)\\]
  //
  selector.walkClasses((node) => {
    if (node.raws && node.value.includes(base)) {
      node.raws.value = escapeClassName(unescape(node.raws.value))
    }
  })

// Remove extraneous selectors that do not include the base candidate
  selector.each((sel) => eliminateIrrelevantSelectors(sel, base))

// If ffter eliminating irrelevant selectors, we end up with nothing
  // Then the whole "rule" this is associated with does not need to exist
  // We use `null` as a marker value for that case
  if (selector.length === 0) {
    return null
  }

// If there are no formats that means there were no variants added to the candidate
  // so we can just return the selector as-is
  let formatAst = Array.isArray(formats)
    ? formatVariantSelector(formats, { context, candidate })
    : formats

if (formatAst === null) {
    return selector.toString()
  }

let simpleStart = selectorParser.comment({ value: '/*__simple__*/' })
  let simpleEnd = selectorParser.comment({ value: '/*__simple__*/' })

// We can safely replace the escaped base now, since the `base` section is
  // now in a normalized escaped value.
  selector.walkClasses((node) => {
    if (node.value !== base) {
      return
    }

let parent = node.parent
    let formatNodes = formatAst.nodes[0].nodes

// Perf optimization: if the parent is a single class we can just replace it and be done
    if (parent.nodes.length === 1) {
      node.replaceWith(...formatNodes)
      return
    }

let simpleSelector = simpleSelectorForNode(node)
    parent.insertBefore(simpleSelector[0], simpleStart)
    parent.insertAfter(simpleSelector[simpleSelector.length - 1], simpleEnd)

for (let child of formatNodes) {
      parent.insertBefore(simpleSelector[0], child.clone())
    }

node.remove()

// Re-sort the simple selector to ensure it's in the correct order
    simpleSelector = simpleSelectorForNode(simpleStart)
    let firstNode = parent.index(simpleStart)

parent.nodes.splice(
      firstNode,
      simpleSelector.length,
      ...resortSelector(selectorParser.selector({ nodes: simpleSelector })).nodes
    )

simpleStart.remove()
    simpleEnd.remove()
  })

// Remove unnecessary pseudo selectors that we used as placeholders
  selector.walkPseudos((p) => {
    if (p.value === MERGE) {
      p.replaceWith(p.nodes)
    }
  })

// Move pseudo elements to the end of the selector (if necessary)
  selector.each((sel) => movePseudos(sel))

return selector.toString()
}

/**
 *
 * @param {Selector} selector
 * @param {Selector} format
 */
export function handleMergePseudo(selector, format) {
  /** @type {{pseudo: Pseudo, value: string}[]} */
  let merges = []

// Find all :merge() pseudo-classes in `selector`
  selector.walkPseudos((pseudo) => {
    if (pseudo.value === MERGE) {
      merges.push({
        pseudo,
        value: pseudo.nodes[0].toString(),
      })
    }
  })

// Find all :merge() "attachments" in `format` and attach them to the matching selector in `selector`
  format.walkPseudos((pseudo) => {
    if (pseudo.value !== MERGE) {
      return
    }

let value = pseudo.nodes[0].toString()

// Does `selector` contain a :merge() pseudo-class with the same value?
    let existing = merges.find((merge) => merge.value === value)

// Nope so there's nothing to do
    if (!existing) {
      return
    }

// Everything after `:merge()` up to the next combinator is what is attached to the merged selector
    let attachments = []
    let next = pseudo.next()
    while (next && next.type !== 'combinator') {
      attachments.push(next)
      next = next.next()
    }

let combinator = next

existing.pseudo.parent.insertAfter(
      existing.pseudo,
      selectorParser.selector({ nodes: attachments.map((node) => node.clone()) })
    )

pseudo.remove()
    attachments.forEach((node) => node.remove())

// What about this case:
    // :merge(.group):focus > &
    // :merge(.group):hover &
    if (combinator && combinator.type === 'combinator') {
      combinator.remove()
    }
  })

return [selector, format]
}

cmd: