Files F101849100

input.js
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Fri, Feb 14, 08:46

input.js
View Options

	'use strict'

	let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
	let { fileURLToPath, pathToFileURL } = require('url')
	let { resolve, isAbsolute } = require('path')
	let { nanoid } = require('nanoid/non-secure')

	let terminalHighlight = require('./terminal-highlight')
	let CssSyntaxError = require('./css-syntax-error')
	let PreviousMap = require('./previous-map')

	let fromOffsetCache = Symbol('fromOffsetCache')

	let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)
	let pathAvailable = Boolean(resolve && isAbsolute)

	class Input {
	constructor(css, opts = {}) {
	if (
	css === null \|\|
	typeof css === 'undefined' \|\|
	(typeof css === 'object' && !css.toString)
	) {
	throw new Error(`PostCSS received ${css} instead of CSS string`)
	}

	this.css = css.toString()

	if (this.css[0] === '\uFEFF' \|\| this.css[0] === '\uFFFE') {
	this.hasBOM = true
	this.css = this.css.slice(1)
	} else {
	this.hasBOM = false
	}

	if (opts.from) {
	if (
	!pathAvailable \|\|
	/^\w+:\/\//.test(opts.from) \|\|
	isAbsolute(opts.from)
	) {
	this.file = opts.from
	} else {
	this.file = resolve(opts.from)
	}
	}

	if (pathAvailable && sourceMapAvailable) {
	let map = new PreviousMap(this.css, opts)
	if (map.text) {
	this.map = map
	let file = map.consumer().file
	if (!this.file && file) this.file = this.mapResolve(file)
	}
	}

	if (!this.file) {
	this.id = '<input css ' + nanoid(6) + '>'
	}
	if (this.map) this.map.file = this.from
	}

	fromOffset(offset) {
	let lastLine, lineToIndex
	if (!this[fromOffsetCache]) {
	let lines = this.css.split('\n')
	lineToIndex = new Array(lines.length)
	let prevIndex = 0

	for (let i = 0, l = lines.length; i < l; i++) {
	lineToIndex[i] = prevIndex
	prevIndex += lines[i].length + 1
	}

	this[fromOffsetCache] = lineToIndex
	} else {
	lineToIndex = this[fromOffsetCache]
	}
	lastLine = lineToIndex[lineToIndex.length - 1]

	let min = 0
	if (offset >= lastLine) {
	min = lineToIndex.length - 1
	} else {
	let max = lineToIndex.length - 2
	let mid
	while (min < max) {
	mid = min + ((max - min) >> 1)
	if (offset < lineToIndex[mid]) {
	max = mid - 1
	} else if (offset >= lineToIndex[mid + 1]) {
	min = mid + 1
	} else {
	min = mid
	break
	}
	}
	}
	return {
	line: min + 1,
	col: offset - lineToIndex[min] + 1
	}
	}

	error(message, line, column, opts = {}) {
	let result, endLine, endColumn

	if (line && typeof line === 'object') {
	let start = line
	let end = column
	if (typeof start.offset === 'number') {
	let pos = this.fromOffset(start.offset)
	line = pos.line
	column = pos.col
	} else {
	line = start.line
	column = start.column
	}
	if (typeof end.offset === 'number') {
	let pos = this.fromOffset(end.offset)
	endLine = pos.line
	endColumn = pos.col
	} else {
	endLine = end.line
	endColumn = end.column
	}
	} else if (!column) {
	let pos = this.fromOffset(line)
	line = pos.line
	column = pos.col
	}

	let origin = this.origin(line, column, endLine, endColumn)
	if (origin) {
	result = new CssSyntaxError(
	message,
	origin.endLine === undefined
	? origin.line
	: { line: origin.line, column: origin.column },
	origin.endLine === undefined
	? origin.column
	: { line: origin.endLine, column: origin.endColumn },
	origin.source,
	origin.file,
	opts.plugin
	)
	} else {
	result = new CssSyntaxError(
	message,
	endLine === undefined ? line : { line, column },
	endLine === undefined ? column : { line: endLine, column: endColumn },
	this.css,
	this.file,
	opts.plugin
	)
	}

	result.input = { line, column, endLine, endColumn, source: this.css }
	if (this.file) {
	if (pathToFileURL) {
	result.input.url = pathToFileURL(this.file).toString()
	}
	result.input.file = this.file
	}

	return result
	}

	origin(line, column, endLine, endColumn) {
	if (!this.map) return false
	let consumer = this.map.consumer()

	let from = consumer.originalPositionFor({ line, column })
	if (!from.source) return false

	let to
	if (typeof endLine === 'number') {
	to = consumer.originalPositionFor({ line: endLine, column: endColumn })
	}

	let fromUrl

	if (isAbsolute(from.source)) {
	fromUrl = pathToFileURL(from.source)
	} else {
	fromUrl = new URL(
	from.source,
	this.map.consumer().sourceRoot \|\| pathToFileURL(this.map.mapFile)
	)
	}

	let result = {
	url: fromUrl.toString(),
	line: from.line,
	column: from.column,
	endLine: to && to.line,
	endColumn: to && to.column
	}

	if (fromUrl.protocol === 'file:') {
	if (fileURLToPath) {
	result.file = fileURLToPath(fromUrl)
	} else {
	/* c8 ignore next 2 */
	throw new Error(`file: protocol is not available in this PostCSS build`)
	}
	}

	let source = consumer.sourceContentFor(from.source)
	if (source) result.source = source

	return result
	}

	mapResolve(file) {
	if (/^\w+:\/\//.test(file)) {
	return file
	}
	return resolve(this.map.consumer().sourceRoot \|\| this.map.root \|\| '.', file)
	}

	get from() {
	return this.file \|\| this.id
	}

	toJSON() {
	let json = {}
	for (let name of ['hasBOM', 'css', 'file', 'id']) {
	if (this[name] != null) {
	json[name] = this[name]
	}
	}
	if (this.map) {
	json.map = { ...this.map }
	if (json.map.consumerCache) {
	json.map.consumerCache = undefined
	}
	}
	return json
	}
	}

	module.exports = Input
	Input.default = Input

	if (terminalHighlight && terminalHighlight.registerInput) {
	terminalHighlight.registerInput(Input)
	}

Event Timeline