Admin

name	type	size	perms	modified	actions
[parent directory]
at-rule.d.ts	file	3,356 B	0664	2026-07-17 04:27:48	edit
at-rule.js	file	471 B	0664	2026-07-17 04:27:44	edit
comment.d.ts	file	1,680 B	0664	2026-07-17 04:27:48	edit
comment.js	file	203 B	0664	2026-07-17 04:27:44	edit
container.d.ts	file	14,025 B	0664	2026-07-17 04:27:48	edit
container.js	file	10,647 B	0664	2026-07-17 04:27:44	edit
css-syntax-error.d.ts	file	6,447 B	0664	2026-07-17 04:27:49	edit
css-syntax-error.js	file	3,402 B	0664	2026-07-17 04:27:44	edit
declaration.d.ts	file	3,833 B	0664	2026-07-17 04:27:49	edit
declaration.js	file	495 B	0664	2026-07-17 04:27:45	edit
document.d.ts	file	1,884 B	0664	2026-07-17 04:27:49	edit
document.js	file	654 B	0664	2026-07-17 04:27:45	edit
fromJSON.d.ts	file	160 B	0664	2026-07-17 04:27:49	edit
fromJSON.js	file	1,506 B	0664	2026-07-17 04:27:47	edit
input.d.ts	file	5,126 B	0664	2026-07-17 04:27:49	edit
input.js	file	6,798 B	0664	2026-07-17 04:27:47	edit
lazy-result.d.ts	file	4,939 B	0664	2026-07-17 04:27:49	edit
lazy-result.js	file	13,869 B	0664	2026-07-17 04:27:47	edit
list.d.ts	file	1,424 B	0664	2026-07-17 04:27:49	edit
list.js	file	1,227 B	0664	2026-07-17 04:27:48	edit
map-generator.js	file	10,031 B	0664	2026-07-17 04:27:48	edit
no-work-result.d.ts	file	1,503 B	0664	2026-07-17 04:27:49	edit
no-work-result.js	file	2,619 B	0664	2026-07-17 04:27:48	edit
node.d.ts	file	14,694 B	0664	2026-07-17 04:27:49	edit
node.js	file	10,719 B	0664	2026-07-17 04:27:48	edit
parse.d.ts	file	133 B	0664	2026-07-17 04:27:49	edit
parse.js	file	1,147 B	0664	2026-07-17 04:27:48	edit
parser.js	file	14,846 B	0664	2026-07-17 04:27:48	edit
postcss.d.mts	file	1,046 B	0664	2026-07-17 04:27:48	edit
postcss.d.ts	file	11,542 B	0664	2026-07-17 04:27:49	edit
postcss.js	file	2,898 B	0664	2026-07-17 04:27:48	edit
postcss.mjs	file	980 B	0664	2026-07-17 04:27:48	edit
previous-map.d.ts	file	1,757 B	0664	2026-07-17 04:27:49	edit
previous-map.js	file	4,508 B	0664	2026-07-17 04:27:48	edit
processor.d.ts	file	3,345 B	0664	2026-07-17 04:27:49	edit
processor.js	file	1,739 B	0664	2026-07-17 04:27:48	edit
result.d.ts	file	4,346 B	0664	2026-07-17 04:27:49	edit
result.js	file	738 B	0664	2026-07-17 04:27:48	edit
root.d.ts	file	2,253 B	0664	2026-07-17 04:27:49	edit
root.js	file	1,239 B	0664	2026-07-17 04:27:48	edit
rule.d.ts	file	2,879 B	0664	2026-07-17 04:27:49	edit
rule.js	file	569 B	0664	2026-07-17 04:27:48	edit
stringifier.d.ts	file	1,360 B	0664	2026-07-17 04:27:49	edit
stringifier.js	file	9,026 B	0664	2026-07-17 04:27:48	edit
stringify.d.ts	file	163 B	0664	2026-07-17 04:27:49	edit
stringify.js	file	213 B	0664	2026-07-17 04:27:48	edit
symbols.js	file	91 B	0664	2026-07-17 04:27:48	edit
terminal-highlight.js	file	1,399 B	0664	2026-07-17 04:27:48	edit
tokenize.js	file	6,700 B	0664	2026-07-17 04:27:48	edit
warn-once.js	file	256 B	0664	2026-07-17 04:27:48	edit
warning.d.ts	file	2,924 B	0664	2026-07-17 04:27:49	edit
warning.js	file	739 B	0664	2026-07-17 04:27:48	edit

editing: map-generator.js

'use strict'

let { dirname, relative, resolve, sep } = require('path')
let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
let { pathToFileURL } = require('url')

let Input = require('./input')

let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)
let pathAvailable = Boolean(dirname && resolve && relative && sep)

class MapGenerator {
  constructor(stringify, root, opts, cssString) {
    this.stringify = stringify
    this.mapOpts = opts.map || {}
    this.root = root
    this.opts = opts
    this.css = cssString
    this.originalCSS = cssString
    this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute

this.memoizedFileURLs = new Map()
    this.memoizedPaths = new Map()
    this.memoizedURLs = new Map()
  }

addAnnotation() {
    let content

if (this.isInline()) {
      content =
        'data:application/json;base64,' + this.toBase64(this.map.toString())
    } else if (typeof this.mapOpts.annotation === 'string') {
      content = this.mapOpts.annotation
    } else if (typeof this.mapOpts.annotation === 'function') {
      content = this.mapOpts.annotation(this.opts.to, this.root)
    } else {
      content = this.outputFile() + '.map'
    }
    let eol = '\n'
    if (this.css.includes('\r\n')) eol = '\r\n'

this.css += eol + '/*# sourceMappingURL=' + content + ' */'
  }

applyPrevMaps() {
    for (let prev of this.previous()) {
      let from = this.toUrl(this.path(prev.file))
      let root = prev.root || dirname(prev.file)
      let map

if (this.mapOpts.sourcesContent === false) {
        map = new SourceMapConsumer(prev.text)
        if (map.sourcesContent) {
          map.sourcesContent = null
        }
      } else {
        map = prev.consumer()
      }

this.map.applySourceMap(map, from, this.toUrl(this.path(root)))
    }
  }

clearAnnotation() {
    if (this.mapOpts.annotation === false) return

if (this.root) {
      let node
      for (let i = this.root.nodes.length - 1; i >= 0; i--) {
        node = this.root.nodes[i]
        if (node.type !== 'comment') continue
        if (node.text.startsWith('# sourceMappingURL=')) {
          this.root.removeChild(i)
        }
      }
    } else if (this.css) {
      let startIndex
      while ((startIndex = this.css.lastIndexOf('/*#')) !== -1) {
        let endIndex = this.css.indexOf('*/', startIndex + 3)
        if (endIndex === -1) break
        while (startIndex > 0 && this.css[startIndex - 1] === '\n') {
          startIndex--
        }
        this.css = this.css.slice(0, startIndex) + this.css.slice(endIndex + 2)
      }
    }
  }

generate() {
    this.clearAnnotation()
    if (pathAvailable && sourceMapAvailable && this.isMap()) {
      return this.generateMap()
    } else {
      let result = ''
      this.stringify(this.root, i => {
        result += i
      })
      return [result]
    }
  }

generateMap() {
    if (this.root) {
      this.generateString()
    } else if (this.previous().length === 1) {
      let prev = this.previous()[0].consumer()
      prev.file = this.outputFile()
      this.map = SourceMapGenerator.fromSourceMap(prev, {
        ignoreInvalidMapping: true
      })
    } else {
      this.map = new SourceMapGenerator({
        file: this.outputFile(),
        ignoreInvalidMapping: true
      })
      this.map.addMapping({
        generated: { column: 0, line: 1 },
        original: { column: 0, line: 1 },
        source: this.opts.from
          ? this.toUrl(this.path(this.opts.from))
          : '<no source>'
      })
    }

if (this.isSourcesContent()) this.setSourcesContent()
    if (this.root && this.previous().length > 0) this.applyPrevMaps()
    if (this.isAnnotation()) this.addAnnotation()

if (this.isInline()) {
      return [this.css]
    } else {
      return [this.css, this.map]
    }
  }

generateString() {
    this.css = ''
    this.map = new SourceMapGenerator({
      file: this.outputFile(),
      ignoreInvalidMapping: true
    })

let line = 1
    let column = 1

let noSource = '<no source>'
    let mapping = {
      generated: { column: 0, line: 0 },
      original: { column: 0, line: 0 },
      source: ''
    }

let last, lines
    this.stringify(this.root, (str, node, type) => {
      this.css += str

if (node && type !== 'end') {
        mapping.generated.line = line
        mapping.generated.column = column - 1
        if (node.source && node.source.start) {
          mapping.source = this.sourcePath(node)
          mapping.original.line = node.source.start.line
          mapping.original.column = node.source.start.column - 1
          this.map.addMapping(mapping)
        } else {
          mapping.source = noSource
          mapping.original.line = 1
          mapping.original.column = 0
          this.map.addMapping(mapping)
        }
      }

lines = str.match(/\n/g)
      if (lines) {
        line += lines.length
        last = str.lastIndexOf('\n')
        column = str.length - last
      } else {
        column += str.length
      }

if (node && type !== 'start') {
        let p = node.parent || { raws: {} }
        let childless =
          node.type === 'decl' || (node.type === 'atrule' && !node.nodes)
        if (!childless || node !== p.last || p.raws.semicolon) {
          if (node.source && node.source.end) {
            mapping.source = this.sourcePath(node)
            mapping.original.line = node.source.end.line
            mapping.original.column = node.source.end.column - 1
            mapping.generated.line = line
            mapping.generated.column = column - 2
            this.map.addMapping(mapping)
          } else {
            mapping.source = noSource
            mapping.original.line = 1
            mapping.original.column = 0
            mapping.generated.line = line
            mapping.generated.column = column - 1
            this.map.addMapping(mapping)
          }
        }
      }
    })
  }

isAnnotation() {
    if (this.isInline()) {
      return true
    }
    if (typeof this.mapOpts.annotation !== 'undefined') {
      return this.mapOpts.annotation
    }
    if (this.previous().length) {
      return this.previous().some(i => i.annotation)
    }
    return true
  }

isInline() {
    if (typeof this.mapOpts.inline !== 'undefined') {
      return this.mapOpts.inline
    }

let annotation = this.mapOpts.annotation
    if (typeof annotation !== 'undefined' && annotation !== true) {
      return false
    }

if (this.previous().length) {
      return this.previous().some(i => i.inline)
    }
    return true
  }

isMap() {
    if (typeof this.opts.map !== 'undefined') {
      return !!this.opts.map
    }
    return this.previous().length > 0
  }

isSourcesContent() {
    if (typeof this.mapOpts.sourcesContent !== 'undefined') {
      return this.mapOpts.sourcesContent
    }
    if (this.previous().length) {
      return this.previous().some(i => i.withContent())
    }
    return true
  }

outputFile() {
    if (this.opts.to) {
      return this.path(this.opts.to)
    } else if (this.opts.from) {
      return this.path(this.opts.from)
    } else {
      return 'to.css'
    }
  }

path(file) {
    if (this.mapOpts.absolute) return file
    if (file.charCodeAt(0) === 60 /* `<` */) return file
    if (/^\w+:\/\//.test(file)) return file
    let cached = this.memoizedPaths.get(file)
    if (cached) return cached

let from = this.opts.to ? dirname(this.opts.to) : '.'

if (typeof this.mapOpts.annotation === 'string') {
      from = dirname(resolve(from, this.mapOpts.annotation))
    }

let path = relative(from, file)
    this.memoizedPaths.set(file, path)

return path
  }

previous() {
    if (!this.previousMaps) {
      this.previousMaps = []
      if (this.root) {
        this.root.walk(node => {
          if (node.source && node.source.input.map) {
            let map = node.source.input.map
            if (!this.previousMaps.includes(map)) {
              this.previousMaps.push(map)
            }
          }
        })
      } else {
        let input = new Input(this.originalCSS, this.opts)
        if (input.map) this.previousMaps.push(input.map)
      }
    }

return this.previousMaps
  }

setSourcesContent() {
    let already = {}
    if (this.root) {
      this.root.walk(node => {
        if (node.source) {
          let from = node.source.input.from
          if (from && !already[from]) {
            already[from] = true
            let fromUrl = this.usesFileUrls
              ? this.toFileUrl(from)
              : this.toUrl(this.path(from))
            this.map.setSourceContent(fromUrl, node.source.input.css)
          }
        }
      })
    } else if (this.css) {
      let from = this.opts.from
        ? this.toUrl(this.path(this.opts.from))
        : '<no source>'
      this.map.setSourceContent(from, this.css)
    }
  }

sourcePath(node) {
    if (this.mapOpts.from) {
      return this.toUrl(this.mapOpts.from)
    } else if (this.usesFileUrls) {
      return this.toFileUrl(node.source.input.from)
    } else {
      return this.toUrl(this.path(node.source.input.from))
    }
  }

toBase64(str) {
    if (Buffer) {
      return Buffer.from(str).toString('base64')
    } else {
      return window.btoa(unescape(encodeURIComponent(str)))
    }
  }

toFileUrl(path) {
    let cached = this.memoizedFileURLs.get(path)
    if (cached) return cached

if (pathToFileURL) {
      let fileURL = pathToFileURL(path).toString()
      this.memoizedFileURLs.set(path, fileURL)

return fileURL
    } else {
      throw new Error(
        '`map.absolute` option is not available in this PostCSS build'
      )
    }
  }

toUrl(path) {
    let cached = this.memoizedURLs.get(path)
    if (cached) return cached

if (sep === '\\') {
      path = path.replace(/\\/g, '/')
    }

let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent)
    this.memoizedURLs.set(path, url)

return url
  }
}

module.exports = MapGenerator

cancel

Admin

editing: map-generator.js

Deskripsi Program

Informasi Donatur

Gerakan Sehat Bermanfaat

Terkumpul

Target

Tentukan Nominal Sedekahmu

Gerakan Sehat Bermanfaat

⁠Masukkan Nominal Sedekah *

Terkumpul

Target