Special logging for PostCSS errors. Makes them very easy to understand.
507725
function rethrowPostcssError(error: Object): WrappedError {
  error.message = `${chalk.yellow('PostCSS error:')} ${error.message}`;
  if (error.name === 'CssSyntaxError') {
    error.message = error.message + '\n' + error.showSourceCode();
  }
  const typedError = wrapError(error, errorTypes.CssCompilationError);
  throw typedError;
}
529231
function parseCssForImports(link, css) {
    link.imports = resolveCssImportUrls(link.url, css)
    status.total += link.imports.length
    result.css += css

    link.imports.forEach(function(importUrl) {
      var importLink = createLink(importUrl, importUrl)
      result.links.push(importLink)

      getLinkContents(importLink.url, options)
        .then(function(css) {
          handleCssFromLink(importLink, css)
        })
        .catch(function(error) {
          link.error = error
          status.parsed++
          handleResolve()
        })
    })
  }
972340
function postprocess(value, logs, options) {
  var tokens = []
  var start = 0
  var match
  var content
  var info
  var parameters
  var end
  var markdown

  EXPRESSION_LOG.lastIndex = 0
  match = EXPRESSION_LOG.exec(value)

  while (match) {
    end = EXPRESSION_LOG.lastIndex

    content = value.slice(start, end - match[0].length)

    parameters = match[2].split(/\s*,\s*/)

    info = parameters[0]
    info = unquote(info.trim())
    info = logs[info]

    if (info && info.value) {
      tokens = tokens.concat(script(content, options), log(info))
    } else {
      parameters = parameters.slice(1).join(', ')

      tokens = tokens.concat(
        script(content + match[1] + parameters + match[3], options)
      )
    }

    start = end
    match = EXPRESSION_LOG.exec(value)
  }

  if (start < value.length) {
    tokens = tokens.concat(script(value.slice(start), options))
  }

  markdown = []

  tokens.forEach(each)

  markdown = markdown.filter(filter)

  return markdown

  function each(token) {
    var prev
    var lang

    if (token.type === 'markdown') {
      markdown = markdown.concat(parse(token.value))
    } else {
      prev = markdown[markdown.length - 1]
      lang = 'lang' in token ? token.lang : token.type

      if (prev && prev.type === 'code' && prev.lang === lang) {
        prev.value += token.value ? '\n' + token.value : ''
      } else {
        markdown.push({
          type: 'code',
          lang: lang,
          value: token.value
        })
      }
    }
  }

  function filter(token) {
    if ('value' in token) {
      token.value = trimTrailingLines(token.value)

      return token.value !== ''
    }

    return true
  }
}
637475
function customLog(message) {
  const trimmed = message.trim()
  const limit = trimmed.indexOf('\n')
  if (limit === -1) {
    fancyLog(trimmed)
  } else {
    const title = trimmed.slice(0, limit).trim()
    const details = trimmed.slice(limit).trim()
    fancyLog(`${title}${('\n' + details).replace(/\n/g, '\n  ')}`)
  }
}
1145942
function getLoggableErrorMessage(error: Error): string | void {
  let result = chalk.red.bold('Error: ');

  if (error instanceof errorTypes.ConfigFatalError) {
    result += 'Fatal configuration error.\n\n';
    result += `${error.message}\n`;
    return result;
  }

  if (error instanceof errorTypes.ConfigValidationError) {
    result += 'Invalid configuration.\n\n';
    if (error.messages) {
      error.messages.forEach((m) => {
        result += `- ${m}\n`;
      });
    } else {
      result += `${error.message}\n`;
    }
    return result;
  }

  if (error instanceof errorTypes.WebpackFatalError) {
    const webpackOptions = [
      'webpackLoaders',
      'webpackPlugins',
      'webpackStaticIgnore'
    ]
      .map((x) => chalk.yellow(x))
      .join(', ');
    result += `Webpack fatal error. Please check any Batfish configuration options that pass directly into Webpack configuration (${webpackOptions}).\n\n`;
    result += `Error message: ${error.originalError.message}\n`;
    return result;
  }

  if (error instanceof errorTypes.WebpackCompilationError) {
    result += `Webpack compilation error.\n\n`;
    const formattedMessages = webpackFormatMessages(error.stats);
    formattedMessages.errors.forEach((errorMessage) => {
      result += `${errorMessage}\n`;
    });
    return result;
  }

  if (error instanceof errorTypes.CssCompilationError) {
    result += `CSS compilation error. This may mean you have non-standard syntax that you forgot to compile with PostCSS.\n\n`;
    result += `${error.message}\n`;
    return result;
  }

  if (error instanceof errorTypes.WebpackNodeParseError) {
    result += `Failed to parse Webpack-compiled version of static-render-pages.js\n\n`;
    result += `Error message: ${error.originalError.message}\n\n`;
    result += renderPrettyErrorStack(error.originalError);
    return result;
  }

  if (error instanceof errorTypes.WebpackNodeExecutionError) {
    result += `Failed to execute Webpack-compiled version of static-render-pages.js.\n\n${chalk.bold.yellow(
      'You may be importing a JS file that cannot run in Node.'
    )}\n\n`;
    result += renderPrettyErrorStack(error.originalError);
    return result;
  }

  if (error instanceof errorTypes.FrontMatterError) {
    result += `Failed to parse front matter in ${chalk.yellow(
      path.relative(process.cwd(), error.filePath)
    )}.\n\n`;
    if (error.originalError.name === 'YAMLException') {
      result += `YAML error: ${error.originalError.reason}\n\n`;
      result += codeFrame.codeFrameColumns(
        error.originalError.mark.buffer,
        {
          start: {
            line: error.originalError.mark.line + 1,
            column: error.originalError.mark.column
          }
        },
        { highlightCode: true, linesAbove: 10, linesBelow: 10 }
      );
    } else {
      result += renderPrettyErrorStack(error.originalError);
    }
    return result;
  }

  return;
}
1236678
def process_styles (out)
      out.gsub /(<style\b[^>]*?>([\s\S]*?)<\/style>)\s*/i do
        css = $2
        m = $1.gsub /^<style\s([^>]+)>/i do |m|
          attrs(m, 'style', true)
        end
        begin
          css_compressed = MultiCss.min css
          m.gsub!(css, css_compressed)
        rescue Exception => e
          log e.message
        end
        reserve m
      end
    end
1004029
function formatMessage(message) {
  let lines = message.split('\n');

  // Remove webpack-specific loader notation from filename.
  // Before:
  // ./~/css-loader!./~/postcss-loader!./src/App.css
  // After:
  // ./src/App.css
  if (lines[0].lastIndexOf('!') !== -1) {
    lines[0] = lines[0].substr(lines[0].lastIndexOf('!') + 1);
  }

  // line #0 is filename
  // line #1 is the main error message
  if (!lines[0] || !lines[1]) {
    return lines.join('\n');
  }

  // Cleans up verbose "module not found" messages for files and packages.
  if (lines[1].indexOf('Module not found: ') === 0) {
    lines = [
      lines[0],
      // Clean up message because "Module not found: " is descriptive enough.
      lines[1]
        .replace("Cannot resolve 'file' or 'directory' ", '')
        .replace('Cannot resolve module ', '')
        .replace('Error: ', ''),
      // Skip all irrelevant lines.
      // (For some reason they only appear on the client in browser.)
      '',
      lines[lines.length - 1] // error location is the last line
    ];
  }

  // Cleans up syntax error messages.
  if (lines[1].indexOf('Module build failed: ') === 0) {
    const cleanedLines = [];
    lines.forEach(line => {
      if (line !== '') {
        cleanedLines.push(line);
      }
    });
    // We are clean now!
    lines = cleanedLines;
    // Finally, brush up the error message a little.
    lines[1] = lines[1].replace('Module build failed: SyntaxError:', friendlySyntaxErrorLabel);
  }

  // Reassemble the message.
  message = lines.join('\n');
  // Internal stacks are generally useless so we strip them... with the
  // exception of stacks containing `webpack:` because they're normally
  // from user code generated by WebPack. For more information see
  // https://github.com/facebookincubator/create-react-app/pull/1050
  message = message.replace(/^\s*at\s((?!webpack:).)*:\d+:\d+[\s)]*(\n|$)/gm, ''); // at ... ...:x:y

  return message;
}
844240
def output_errors(title, options = {}, fields = nil, flash_only = false)
      fields = [fields] unless fields.is_a?(Array)
      flash_html = render(:partial => 'shared/flash_messages')
      flash.clear
      css_class = "class=\"#{options[:class] || 'error'}\"" unless options[:class].nil?
      field_errors = render(:partial => 'shared/field_error', :collection => fields)

      if flash_only || (!flash_html.empty? && field_errors.empty?)
        # Only flash.  Don't render errors for any fields
        render(:partial => 'shared/flash_error_box', :locals => {:flash_html => flash_html, :css_class => css_class})
      elsif !field_errors.empty?
        # Field errors and/or flash
        render(:partial => 'shared/error_box', :locals => {:title => title,
          :flash_html => flash_html,
          :field_errors => field_errors,
          :css_class => css_class,
          :extra_html => options[:extra_html]})
      else
        #nothing
        ''
      end
    end
930446
function handleError(message, url, line) {
        // Ignore this error if it does not look like the rather vague cross origin error in Chrome
        // Chrome will print it to the console anyway
        if (!testCrossOriginError(message, url, line)) {
            if (previousErrorHandler) {
                return previousErrorHandler(message, url, line);
            }
            return;
        }

        // Show an error message
        window.alert("Oops! This application doesn't run in browsers yet.\n\nIt is built in HTML, but right now it runs as a desktop app so you can use it to edit local files. Please use the application shell in the following repo to run this application:\n\ngithub.com/adobe/brackets-shell");

        // Restore the original handler for later errors
        window.onerror = previousErrorHandler;
    }
963910
function(css) {
  css = css
    // remove comments
    .replace(/\/\*[^\0]*?\*\//g, '')
    // trim space before characters
    .replace(/\s+({|})/g, '$1')
    // trim space after characters
    .replace(/(;|,|:|{|}|^)\s+/g, '$1')
    // trim combinators
    .replace(/\s+(>|\+|~)\s+/g, '$1')
    // remove escaped newlines and spaces
    .replace(/\\\r?\n\s+/g, '')
    // remove trailing semicolons in rules
    .replace(/;(})/g, '$1');

  return css;
}
694022
function colorErrors(stdLine) {
  // lazy load chalk
  if (chalk === undefined) {
    chalk = require("chalk");
  }

  return colorErrorPatterns.reduce((op, pattern) => {
    const matches = pattern.exec(op);

    if (matches !== null && matches.length > 0) {
      op = op.replace(pattern, chalk.red(matches[0]));
    }

    return op;
  }, stdLine);
}
404639
def autoprefixCSS(sassPath):
    '''
    

    '''
    print("Autoprefixing CSS")
    cssPath = os.path.splitext(sassPath)[0] + ".css"
    command = "postcss --use autoprefixer --autoprefixer.browsers '> 5%' -o" + cssPath + " " + cssPath
    subprocess.call(command, shell=True)
562673
function(err, req, res, next) {
    err.message = err.message || 'Internal Server Error';
    err.code = err.code || res.code || 500;
    if (!_.isNumber(err.code)) {
      err.code = 500;
    }

    try {
      err.line = err.stack.split('\n')[1].match(/\(.+\)/)[0];
    } catch (e) {
      err.line = null;
    }

    var envelope = {
      meta: {
        code: err.code,
        error: {
          code: err.code,
          message: err.message,
          line: err.line
        }
      },
      data: err.message
    };

    // Set code and data
    res.code = err.code;
    res.data = envelope;

    return next();
  }
528745
function highlightPostSyntax( post ) {

	var codeTags = [],
			i = 0,
			len = 0;

	doc = doc || createDom( post.content );
	
	codeTags = doc.querySelectorAll('pre code');

	len = codeTags.length;

	for ( ; i < len; i++ ) {

		// Replace class names beginning with "lang-" with "language-" for Highlight.js
		codeTags[i].className = codeTags[i].className.replace('lang-', 'language-');

		hljs.highlightBlock( codeTags[i] );
	}

	post.content = doc.body.innerHTML;
}
43378
function reTypeError(error: *): Error {
  if (error.name === 'CssCompilationError') {
    return wrapError(error, errorTypes.CssCompilationError, {
      originalError: error.originalError
    });
  }
  return error;
}
94851
function logJsHintWarning (errors)
{
    totalIssues += errors.length;

    var sourceFile = pathHelper.makeRelative(this.resourcePath);
    gulpUtil.log(gulpUtil.colors.yellow("jshint warning") + " in " + sourceFile);

    for (var i = 0, l = errors.length; i < l; i++)
    {
        var error = errors[i];

        gulpUtil.log(
            "    in " +
            gulpUtil.colors.blue("line " + error.line + " @ char " + error.character) +
            ": " +
            error.reason +
            " (" + error.code + ")"
        );

        if (typeof error.evidence === "string")
        {
            gulpUtil.log(
                "        " +
                gulpUtil.colors.gray(error.evidence.replace(/^\s*|\s*$/, ""))
            );
        }

        gulpUtil.log("");
    }
}
144822
public function _amp_post_template_css() {
		ob_start();
		$this->_print_front_styles();
		$css = ob_get_clean();
		$css = str_replace( '!important', '', $css );
		// @codingStandardsIgnoreStart
		echo $css;
		// @codingStandardsIgnoreEnd
	}