ONE PIECE HACKING

Ngiler SH3LL 360
: / home / tbf / new2023.tbf.ro / node_modules / postcss-import /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	89.40.16.97
System	Linux server.atelieruldeit.ro 3.10.0-1160.el7.x86_64 #1 SMP Mon Oct 19 16:18:59 UTC 2020 x86_64
User	tbf
PHP Version	7.3.33
Software	Apache
Doc root	Writable

Edit File : index.js \| Size : 12.88 KB
"use strict" // builtin tooling const path = require("path") // internal tooling const joinMedia = require("./lib/join-media") const joinLayer = require("./lib/join-layer") const resolveId = require("./lib/resolve-id") const loadContent = require("./lib/load-content") const processContent = require("./lib/process-content") const parseStatements = require("./lib/parse-statements") const assignLayerNames = require("./lib/assign-layer-names") const dataURL = require("./lib/data-url") function AtImport(options) { options = { root: process.cwd(), path: [], skipDuplicates: true, resolve: resolveId, load: loadContent, plugins: [], addModulesDirectories: [], nameLayer: null, ...options, } options.root = path.resolve(options.root) // convert string to an array of a single element if (typeof options.path === "string") options.path = [options.path] if (!Array.isArray(options.path)) options.path = [] options.path = options.path.map(p => path.resolve(options.root, p)) return { postcssPlugin: "postcss-import", Once(styles, { result, atRule, postcss }) { const state = { importedFiles: {}, hashFiles: {}, rootFilename: null, anonymousLayerCounter: 0, } if (styles.source?.input?.file) { state.rootFilename = styles.source.input.file state.importedFiles[styles.source.input.file] = {} } if (options.plugins && !Array.isArray(options.plugins)) { throw new Error("plugins option must be an array") } if (options.nameLayer && typeof options.nameLayer !== "function") { throw new Error("nameLayer option must be a function") } return parseStyles(result, styles, options, state, [], []).then( bundle => { applyRaws(bundle) applyMedia(bundle) applyStyles(bundle, styles) } ) function applyRaws(bundle) { bundle.forEach((stmt, index) => { if (index === 0) return if (stmt.parent) { const { before } = stmt.parent.node.raws if (stmt.type === "nodes") stmt.nodes[0].raws.before = before else stmt.node.raws.before = before } else if (stmt.type === "nodes") { stmt.nodes[0].raws.before = stmt.nodes[0].raws.before \|\| "\n" } }) } function applyMedia(bundle) { bundle.forEach(stmt => { if ( (!stmt.media.length && !stmt.layer.length) \|\| stmt.type === "charset" ) { return } if (stmt.layer.length > 1) { assignLayerNames(stmt.layer, stmt.node, state, options) } if (stmt.type === "import") { const parts = [stmt.fullUri] const media = stmt.media.join(", ") if (stmt.layer.length) { const layerName = stmt.layer.join(".") let layerParams = "layer" if (layerName) { layerParams = `layer(${layerName})` } parts.push(layerParams) } if (media) { parts.push(media) } stmt.node.params = parts.join(" ") } else if (stmt.type === "media") { if (stmt.layer.length) { const layerNode = atRule({ name: "layer", params: stmt.layer.join("."), source: stmt.node.source, }) if (stmt.parentMedia?.length) { const mediaNode = atRule({ name: "media", params: stmt.parentMedia.join(", "), source: stmt.node.source, }) mediaNode.append(layerNode) layerNode.append(stmt.node) stmt.node = mediaNode } else { layerNode.append(stmt.node) stmt.node = layerNode } } else { stmt.node.params = stmt.media.join(", ") } } else { const { nodes } = stmt const { parent } = nodes[0] let outerAtRule let innerAtRule if (stmt.media.length && stmt.layer.length) { const mediaNode = atRule({ name: "media", params: stmt.media.join(", "), source: parent.source, }) const layerNode = atRule({ name: "layer", params: stmt.layer.join("."), source: parent.source, }) mediaNode.append(layerNode) innerAtRule = layerNode outerAtRule = mediaNode } else if (stmt.media.length) { const mediaNode = atRule({ name: "media", params: stmt.media.join(", "), source: parent.source, }) innerAtRule = mediaNode outerAtRule = mediaNode } else if (stmt.layer.length) { const layerNode = atRule({ name: "layer", params: stmt.layer.join("."), source: parent.source, }) innerAtRule = layerNode outerAtRule = layerNode } parent.insertBefore(nodes[0], outerAtRule) // remove nodes nodes.forEach(node => { node.parent = undefined }) // better output nodes[0].raws.before = nodes[0].raws.before \|\| "\n" // wrap new rules with media query and/or layer at rule innerAtRule.append(nodes) stmt.type = "media" stmt.node = outerAtRule delete stmt.nodes } }) } function applyStyles(bundle, styles) { styles.nodes = [] // Strip additional statements. bundle.forEach(stmt => { if (["charset", "import", "media"].includes(stmt.type)) { stmt.node.parent = undefined styles.append(stmt.node) } else if (stmt.type === "nodes") { stmt.nodes.forEach(node => { node.parent = undefined styles.append(node) }) } }) } function parseStyles(result, styles, options, state, media, layer) { const statements = parseStatements(result, styles) return Promise.resolve(statements) .then(stmts => { // process each statement in series return stmts.reduce((promise, stmt) => { return promise.then(() => { stmt.media = joinMedia(media, stmt.media \|\| []) stmt.parentMedia = media stmt.layer = joinLayer(layer, stmt.layer \|\| []) // skip protocol base uri (protocol://url) or protocol-relative if ( stmt.type !== "import" \|\| /^(?:[a-z]+:)?\/\//i.test(stmt.uri) ) { return } if (options.filter && !options.filter(stmt.uri)) { // rejected by filter return } return resolveImportId(result, stmt, options, state) }) }, Promise.resolve()) }) .then(() => { let charset const imports = [] const bundle = [] function handleCharset(stmt) { if (!charset) charset = stmt // charsets aren't case-sensitive, so convert to lower case to compare else if ( stmt.node.params.toLowerCase() !== charset.node.params.toLowerCase() ) { throw new Error( `Incompatable @charset statements: ${stmt.node.params} specified in ${stmt.node.source.input.file} ${charset.node.params} specified in ${charset.node.source.input.file}` ) } } // squash statements and their children statements.forEach(stmt => { if (stmt.type === "charset") handleCharset(stmt) else if (stmt.type === "import") { if (stmt.children) { stmt.children.forEach((child, index) => { if (child.type === "import") imports.push(child) else if (child.type === "charset") handleCharset(child) else bundle.push(child) // For better output if (index === 0) child.parent = stmt }) } else imports.push(stmt) } else if (stmt.type === "media" \|\| stmt.type === "nodes") { bundle.push(stmt) } }) return charset ? [charset, ...imports.concat(bundle)] : imports.concat(bundle) }) } function resolveImportId(result, stmt, options, state) { if (dataURL.isValid(stmt.uri)) { return loadImportContent(result, stmt, stmt.uri, options, state).then( result => { stmt.children = result } ) } const atRule = stmt.node let sourceFile if (atRule.source?.input?.file) { sourceFile = atRule.source.input.file } const base = sourceFile ? path.dirname(atRule.source.input.file) : options.root return Promise.resolve(options.resolve(stmt.uri, base, options)) .then(paths => { if (!Array.isArray(paths)) paths = [paths] // Ensure that each path is absolute: return Promise.all( paths.map(file => { return !path.isAbsolute(file) ? resolveId(file, base, options) : file }) ) }) .then(resolved => { // Add dependency messages: resolved.forEach(file => { result.messages.push({ type: "dependency", plugin: "postcss-import", file, parent: sourceFile, }) }) return Promise.all( resolved.map(file => { return loadImportContent(result, stmt, file, options, state) }) ) }) .then(result => { // Merge loaded statements stmt.children = result.reduce((result, statements) => { return statements ? result.concat(statements) : result }, []) }) } function loadImportContent(result, stmt, filename, options, state) { const atRule = stmt.node const { media, layer } = stmt assignLayerNames(layer, atRule, state, options) if (options.skipDuplicates) { // skip files already imported at the same scope if (state.importedFiles[filename]?.[media]?.[layer]) { return } // save imported files to skip them next time if (!state.importedFiles[filename]) { state.importedFiles[filename] = {} } if (!state.importedFiles[filename][media]) { state.importedFiles[filename][media] = {} } state.importedFiles[filename][media][layer] = true } return Promise.resolve(options.load(filename, options)).then( content => { if (content.trim() === "") { result.warn(`${filename} is empty`, { node: atRule }) return } // skip previous imported files not containing @import rules if (state.hashFiles[content]?.[media]?.[layer]) { return } return processContent( result, content, filename, options, postcss ).then(importedResult => { const styles = importedResult.root result.messages = result.messages.concat(importedResult.messages) if (options.skipDuplicates) { const hasImport = styles.some(child => { return child.type === "atrule" && child.name === "import" }) if (!hasImport) { // save hash files to skip them next time if (!state.hashFiles[content]) { state.hashFiles[content] = {} } if (!state.hashFiles[content][media]) { state.hashFiles[content][media] = {} } state.hashFiles[content][media][layer] = true } } // recursion: import @import from imported file return parseStyles(result, styles, options, state, media, layer) }) } ) } }, } } AtImport.postcss = true module.exports = AtImport Back

Edit File : index.js | Size : 12.88 KB

"use strict"
// builtin tooling
const path = require("path")

// internal tooling
const joinMedia = require("./lib/join-media")
const joinLayer = require("./lib/join-layer")
const resolveId = require("./lib/resolve-id")
const loadContent = require("./lib/load-content")
const processContent = require("./lib/process-content")
const parseStatements = require("./lib/parse-statements")
const assignLayerNames = require("./lib/assign-layer-names")
const dataURL = require("./lib/data-url")

function AtImport(options) {
  options = {
    root: process.cwd(),
    path: [],
    skipDuplicates: true,
    resolve: resolveId,
    load: loadContent,
    plugins: [],
    addModulesDirectories: [],
    nameLayer: null,
    ...options,
  }

options.root = path.resolve(options.root)

// convert string to an array of a single element
  if (typeof options.path === "string") options.path = [options.path]

if (!Array.isArray(options.path)) options.path = []

options.path = options.path.map(p => path.resolve(options.root, p))

return {
    postcssPlugin: "postcss-import",
    Once(styles, { result, atRule, postcss }) {
      const state = {
        importedFiles: {},
        hashFiles: {},
        rootFilename: null,
        anonymousLayerCounter: 0,
      }

if (styles.source?.input?.file) {
        state.rootFilename = styles.source.input.file
        state.importedFiles[styles.source.input.file] = {}
      }

if (options.plugins && !Array.isArray(options.plugins)) {
        throw new Error("plugins option must be an array")
      }

if (options.nameLayer && typeof options.nameLayer !== "function") {
        throw new Error("nameLayer option must be a function")
      }

return parseStyles(result, styles, options, state, [], []).then(
        bundle => {
          applyRaws(bundle)
          applyMedia(bundle)
          applyStyles(bundle, styles)
        }
      )

function applyRaws(bundle) {
        bundle.forEach((stmt, index) => {
          if (index === 0) return

if (stmt.parent) {
            const { before } = stmt.parent.node.raws
            if (stmt.type === "nodes") stmt.nodes[0].raws.before = before
            else stmt.node.raws.before = before
          } else if (stmt.type === "nodes") {
            stmt.nodes[0].raws.before = stmt.nodes[0].raws.before || "\n"
          }
        })
      }

function applyMedia(bundle) {
        bundle.forEach(stmt => {
          if (
            (!stmt.media.length && !stmt.layer.length) ||
            stmt.type === "charset"
          ) {
            return
          }

if (stmt.layer.length > 1) {
            assignLayerNames(stmt.layer, stmt.node, state, options)
          }

if (stmt.type === "import") {
            const parts = [stmt.fullUri]

const media = stmt.media.join(", ")

if (stmt.layer.length) {
              const layerName = stmt.layer.join(".")

let layerParams = "layer"
              if (layerName) {
                layerParams = `layer(${layerName})`
              }

parts.push(layerParams)
            }

if (media) {
              parts.push(media)
            }

stmt.node.params = parts.join(" ")
          } else if (stmt.type === "media") {
            if (stmt.layer.length) {
              const layerNode = atRule({
                name: "layer",
                params: stmt.layer.join("."),
                source: stmt.node.source,
              })

if (stmt.parentMedia?.length) {
                const mediaNode = atRule({
                  name: "media",
                  params: stmt.parentMedia.join(", "),
                  source: stmt.node.source,
                })

mediaNode.append(layerNode)
                layerNode.append(stmt.node)
                stmt.node = mediaNode
              } else {
                layerNode.append(stmt.node)
                stmt.node = layerNode
              }
            } else {
              stmt.node.params = stmt.media.join(", ")
            }
          } else {
            const { nodes } = stmt
            const { parent } = nodes[0]

let outerAtRule
            let innerAtRule
            if (stmt.media.length && stmt.layer.length) {
              const mediaNode = atRule({
                name: "media",
                params: stmt.media.join(", "),
                source: parent.source,
              })

const layerNode = atRule({
                name: "layer",
                params: stmt.layer.join("."),
                source: parent.source,
              })

mediaNode.append(layerNode)
              innerAtRule = layerNode
              outerAtRule = mediaNode
            } else if (stmt.media.length) {
              const mediaNode = atRule({
                name: "media",
                params: stmt.media.join(", "),
                source: parent.source,
              })

innerAtRule = mediaNode
              outerAtRule = mediaNode
            } else if (stmt.layer.length) {
              const layerNode = atRule({
                name: "layer",
                params: stmt.layer.join("."),
                source: parent.source,
              })

innerAtRule = layerNode
              outerAtRule = layerNode
            }

parent.insertBefore(nodes[0], outerAtRule)

// remove nodes
            nodes.forEach(node => {
              node.parent = undefined
            })

// better output
            nodes[0].raws.before = nodes[0].raws.before || "\n"

// wrap new rules with media query and/or layer at rule
            innerAtRule.append(nodes)

stmt.type = "media"
            stmt.node = outerAtRule
            delete stmt.nodes
          }
        })
      }

function applyStyles(bundle, styles) {
        styles.nodes = []

// Strip additional statements.
        bundle.forEach(stmt => {
          if (["charset", "import", "media"].includes(stmt.type)) {
            stmt.node.parent = undefined
            styles.append(stmt.node)
          } else if (stmt.type === "nodes") {
            stmt.nodes.forEach(node => {
              node.parent = undefined
              styles.append(node)
            })
          }
        })
      }

function parseStyles(result, styles, options, state, media, layer) {
        const statements = parseStatements(result, styles)

return Promise.resolve(statements)
          .then(stmts => {
            // process each statement in series
            return stmts.reduce((promise, stmt) => {
              return promise.then(() => {
                stmt.media = joinMedia(media, stmt.media || [])
                stmt.parentMedia = media
                stmt.layer = joinLayer(layer, stmt.layer || [])

// skip protocol base uri (protocol://url) or protocol-relative
                if (
                  stmt.type !== "import" ||
                  /^(?:[a-z]+:)?\/\//i.test(stmt.uri)
                ) {
                  return
                }

if (options.filter && !options.filter(stmt.uri)) {
                  // rejected by filter
                  return
                }

return resolveImportId(result, stmt, options, state)
              })
            }, Promise.resolve())
          })
          .then(() => {
            let charset
            const imports = []
            const bundle = []

function handleCharset(stmt) {
              if (!charset) charset = stmt
              // charsets aren't case-sensitive, so convert to lower case to compare
              else if (
                stmt.node.params.toLowerCase() !==
                charset.node.params.toLowerCase()
              ) {
                throw new Error(
                  `Incompatable @charset statements:
  ${stmt.node.params} specified in ${stmt.node.source.input.file}
  ${charset.node.params} specified in ${charset.node.source.input.file}`
                )
              }
            }

// squash statements and their children
            statements.forEach(stmt => {
              if (stmt.type === "charset") handleCharset(stmt)
              else if (stmt.type === "import") {
                if (stmt.children) {
                  stmt.children.forEach((child, index) => {
                    if (child.type === "import") imports.push(child)
                    else if (child.type === "charset") handleCharset(child)
                    else bundle.push(child)
                    // For better output
                    if (index === 0) child.parent = stmt
                  })
                } else imports.push(stmt)
              } else if (stmt.type === "media" || stmt.type === "nodes") {
                bundle.push(stmt)
              }
            })

return charset
              ? [charset, ...imports.concat(bundle)]
              : imports.concat(bundle)
          })
      }

function resolveImportId(result, stmt, options, state) {
        if (dataURL.isValid(stmt.uri)) {
          return loadImportContent(result, stmt, stmt.uri, options, state).then(
            result => {
              stmt.children = result
            }
          )
        }

const atRule = stmt.node
        let sourceFile
        if (atRule.source?.input?.file) {
          sourceFile = atRule.source.input.file
        }
        const base = sourceFile
          ? path.dirname(atRule.source.input.file)
          : options.root

return Promise.resolve(options.resolve(stmt.uri, base, options))
          .then(paths => {
            if (!Array.isArray(paths)) paths = [paths]
            // Ensure that each path is absolute:
            return Promise.all(
              paths.map(file => {
                return !path.isAbsolute(file)
                  ? resolveId(file, base, options)
                  : file
              })
            )
          })
          .then(resolved => {
            // Add dependency messages:
            resolved.forEach(file => {
              result.messages.push({
                type: "dependency",
                plugin: "postcss-import",
                file,
                parent: sourceFile,
              })
            })

return Promise.all(
              resolved.map(file => {
                return loadImportContent(result, stmt, file, options, state)
              })
            )
          })
          .then(result => {
            // Merge loaded statements
            stmt.children = result.reduce((result, statements) => {
              return statements ? result.concat(statements) : result
            }, [])
          })
      }

function loadImportContent(result, stmt, filename, options, state) {
        const atRule = stmt.node
        const { media, layer } = stmt

assignLayerNames(layer, atRule, state, options)

if (options.skipDuplicates) {
          // skip files already imported at the same scope
          if (state.importedFiles[filename]?.[media]?.[layer]) {
            return
          }

// save imported files to skip them next time
          if (!state.importedFiles[filename]) {
            state.importedFiles[filename] = {}
          }
          if (!state.importedFiles[filename][media]) {
            state.importedFiles[filename][media] = {}
          }
          state.importedFiles[filename][media][layer] = true
        }

return Promise.resolve(options.load(filename, options)).then(
          content => {
            if (content.trim() === "") {
              result.warn(`${filename} is empty`, { node: atRule })
              return
            }

// skip previous imported files not containing @import rules
            if (state.hashFiles[content]?.[media]?.[layer]) {
              return
            }

return processContent(
              result,
              content,
              filename,
              options,
              postcss
            ).then(importedResult => {
              const styles = importedResult.root
              result.messages = result.messages.concat(importedResult.messages)

if (options.skipDuplicates) {
                const hasImport = styles.some(child => {
                  return child.type === "atrule" && child.name === "import"
                })
                if (!hasImport) {
                  // save hash files to skip them next time
                  if (!state.hashFiles[content]) {
                    state.hashFiles[content] = {}
                  }
                  if (!state.hashFiles[content][media]) {
                    state.hashFiles[content][media] = {}
                  }
                  state.hashFiles[content][media][layer] = true
                }
              }

// recursion: import @import from imported file
              return parseStyles(result, styles, options, state, media, layer)
            })
          }
        )
      }
    },
  }
}

AtImport.postcss = true

module.exports = AtImport

Back