www.aleph1.co.uk Git - yaffs-website/blob - node_modules/postcss/lib/previous-map.js

   1 'use strict';
   2
   3 exports.__esModule = true;
   4
   5 var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
   6
   7 var _jsBase = require('js-base64');
   8
   9 var _sourceMap = require('source-map');
  10
  11 var _sourceMap2 = _interopRequireDefault(_sourceMap);
  12
  13 var _path = require('path');
  14
  15 var _path2 = _interopRequireDefault(_path);
  16
  17 var _fs = require('fs');
  18
  19 var _fs2 = _interopRequireDefault(_fs);
  20
  21 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  22
  23 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  24
  25 /**
  26  * Source map information from input CSS.
  27  * For example, source map after Sass compiler.
  28  *
  29  * This class will automatically find source map in input CSS or in file system
  30  * near input file (according `from` option).
  31  *
  32  * @example
  33  * const root = postcss.parse(css, { from: 'a.sass.css' });
  34  * root.input.map //=> PreviousMap
  35  */
  36 var PreviousMap = function () {
  37
  38     /**
  39      * @param {string}         css    - input CSS source
  40      * @param {processOptions} [opts] - {@link Processor#process} options
  41      */
  42     function PreviousMap(css, opts) {
  43         _classCallCheck(this, PreviousMap);
  44
  45         this.loadAnnotation(css);
  46         /**
  47          * @member {boolean} - Was source map inlined by data-uri to input CSS.
  48          */
  49         this.inline = this.startWith(this.annotation, 'data:');
  50
  51         var prev = opts.map ? opts.map.prev : undefined;
  52         var text = this.loadMap(opts.from, prev);
  53         if (text) this.text = text;
  54     }
  55
  56     /**
  57      * Create a instance of `SourceMapGenerator` class
  58      * from the `source-map` library to work with source map information.
  59      *
  60      * It is lazy method, so it will create object only on first call
  61      * and then it will use cache.
  62      *
  63      * @return {SourceMapGenerator} object with source map information
  64      */
  65
  66
  67     PreviousMap.prototype.consumer = function consumer() {
  68         if (!this.consumerCache) {
  69             this.consumerCache = new _sourceMap2.default.SourceMapConsumer(this.text);
  70         }
  71         return this.consumerCache;
  72     };
  73
  74     /**
  75      * Does source map contains `sourcesContent` with input source text.
  76      *
  77      * @return {boolean} Is `sourcesContent` present
  78      */
  79
  80
  81     PreviousMap.prototype.withContent = function withContent() {
  82         return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
  83     };
  84
  85     PreviousMap.prototype.startWith = function startWith(string, start) {
  86         if (!string) return false;
  87         return string.substr(0, start.length) === start;
  88     };
  89
  90     PreviousMap.prototype.loadAnnotation = function loadAnnotation(css) {
  91         var match = css.match(/\/\*\s*# sourceMappingURL=(.*)\s*\*\//);
  92         if (match) this.annotation = match[1].trim();
  93     };
  94
  95     PreviousMap.prototype.decodeInline = function decodeInline(text) {
  96         var utfd64 = 'data:application/json;charset=utf-8;base64,';
  97         var utf64 = 'data:application/json;charset=utf8;base64,';
  98         var b64 = 'data:application/json;base64,';
  99         var uri = 'data:application/json,';
 100
 101         if (this.startWith(text, uri)) {
 102             return decodeURIComponent(text.substr(uri.length));
 103         } else if (this.startWith(text, b64)) {
 104             return _jsBase.Base64.decode(text.substr(b64.length));
 105         } else if (this.startWith(text, utf64)) {
 106             return _jsBase.Base64.decode(text.substr(utf64.length));
 107         } else if (this.startWith(text, utfd64)) {
 108             return _jsBase.Base64.decode(text.substr(utfd64.length));
 109         } else {
 110             var encoding = text.match(/data:application\/json;([^,]+),/)[1];
 111             throw new Error('Unsupported source map encoding ' + encoding);
 112         }
 113     };
 114
 115     PreviousMap.prototype.loadMap = function loadMap(file, prev) {
 116         if (prev === false) return false;
 117
 118         if (prev) {
 119             if (typeof prev === 'string') {
 120                 return prev;
 121             } else if (typeof prev === 'function') {
 122                 var prevPath = prev(file);
 123                 if (prevPath && _fs2.default.existsSync && _fs2.default.existsSync(prevPath)) {
 124                     return _fs2.default.readFileSync(prevPath, 'utf-8').toString().trim();
 125                 } else {
 126                     throw new Error('Unable to load previous source map: ' + prevPath.toString());
 127                 }
 128             } else if (prev instanceof _sourceMap2.default.SourceMapConsumer) {
 129                 return _sourceMap2.default.SourceMapGenerator.fromSourceMap(prev).toString();
 130             } else if (prev instanceof _sourceMap2.default.SourceMapGenerator) {
 131                 return prev.toString();
 132             } else if (this.isMap(prev)) {
 133                 return JSON.stringify(prev);
 134             } else {
 135                 throw new Error('Unsupported previous source map format: ' + prev.toString());
 136             }
 137         } else if (this.inline) {
 138             return this.decodeInline(this.annotation);
 139         } else if (this.annotation) {
 140             var map = this.annotation;
 141             if (file) map = _path2.default.join(_path2.default.dirname(file), map);
 142
 143             this.root = _path2.default.dirname(map);
 144             if (_fs2.default.existsSync && _fs2.default.existsSync(map)) {
 145                 return _fs2.default.readFileSync(map, 'utf-8').toString().trim();
 146             } else {
 147                 return false;
 148             }
 149         }
 150     };
 151
 152     PreviousMap.prototype.isMap = function isMap(map) {
 153         if ((typeof map === 'undefined' ? 'undefined' : _typeof(map)) !== 'object') return false;
 154         return typeof map.mappings === 'string' || typeof map._mappings === 'string';
 155     };
 156
 157     return PreviousMap;
 158 }();
 159
 160 exports.default = PreviousMap;
 161 module.exports = exports['default'];
 162 //# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["previous-map.es6"],"names":["PreviousMap","css","opts","loadAnnotation","inline","startWith","annotation","prev","map","undefined","text","loadMap","from","consumer","consumerCache","SourceMapConsumer","withContent","sourcesContent","length","string","start","substr","match","trim","decodeInline","utfd64","utf64","b64","uri","decodeURIComponent","decode","encoding","Error","file","prevPath","existsSync","readFileSync","toString","SourceMapGenerator","fromSourceMap","isMap","JSON","stringify","join","dirname","root","mappings","_mappings"],"mappings":"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","file":"previous-map.js","sourcesContent":["import { Base64 } from 'js-base64';\nimport   mozilla  from 'source-map';\nimport   path     from 'path';\nimport   fs       from 'fs';\n\n/**\n * Source map information from input CSS.\n * For example, source map after Sass compiler.\n *\n * This class will automatically find source map in input CSS or in file system\n * near input file (according `from` option).\n *\n * @example\n * const root = postcss.parse(css, { from: 'a.sass.css' });\n * root.input.map //=> PreviousMap\n */\nclass PreviousMap {\n\n    /**\n     * @param {string}         css    - input CSS source\n     * @param {processOptions} [opts] - {@link Processor#process} options\n     */\n    constructor(css, opts) {\n        this.loadAnnotation(css);\n        /**\n         * @member {boolean} - Was source map inlined by data-uri to input CSS.\n         */\n        this.inline = this.startWith(this.annotation, 'data:');\n\n        let prev = opts.map ? opts.map.prev : undefined;\n        let text = this.loadMap(opts.from, prev);\n        if ( text ) this.text = text;\n    }\n\n    /**\n     * Create a instance of `SourceMapGenerator` class\n     * from the `source-map` library to work with source map information.\n     *\n     * It is lazy method, so it will create object only on first call\n     * and then it will use cache.\n     *\n     * @return {SourceMapGenerator} object with source map information\n     */\n    consumer() {\n        if ( !this.consumerCache ) {\n            this.consumerCache = new mozilla.SourceMapConsumer(this.text);\n        }\n        return this.consumerCache;\n    }\n\n    /**\n     * Does source map contains `sourcesContent` with input source text.\n     *\n     * @return {boolean} Is `sourcesContent` present\n     */\n    withContent() {\n        return !!(this.consumer().sourcesContent &&\n                  this.consumer().sourcesContent.length > 0);\n    }\n\n    startWith(string, start) {\n        if ( !string ) return false;\n        return string.substr(0, start.length) === start;\n    }\n\n    loadAnnotation(css) {\n        let match = css.match(/\\/\\*\\s*# sourceMappingURL=(.*)\\s*\\*\\//);\n        if ( match ) this.annotation = match[1].trim();\n    }\n\n    decodeInline(text) {\n        let utfd64 = 'data:application/json;charset=utf-8;base64,';\n        let utf64  = 'data:application/json;charset=utf8;base64,';\n        let b64    = 'data:application/json;base64,';\n        let uri    = 'data:application/json,';\n\n        if ( this.startWith(text, uri) ) {\n            return decodeURIComponent( text.substr(uri.length) );\n\n        } else if ( this.startWith(text, b64) ) {\n            return Base64.decode( text.substr(b64.length) );\n\n        } else if ( this.startWith(text, utf64) ) {\n            return Base64.decode( text.substr(utf64.length) );\n\n        } else if ( this.startWith(text, utfd64) ) {\n            return Base64.decode( text.substr(utfd64.length) );\n\n        } else {\n            let encoding = text.match(/data:application\\/json;([^,]+),/)[1];\n            throw new Error('Unsupported source map encoding ' + encoding);\n        }\n    }\n\n    loadMap(file, prev) {\n        if ( prev === false ) return false;\n\n        if ( prev ) {\n            if ( typeof prev === 'string' ) {\n                return prev;\n            } else if ( typeof prev === 'function' ) {\n                let prevPath = prev(file);\n                if ( prevPath && fs.existsSync && fs.existsSync(prevPath) ) {\n                    return fs.readFileSync(prevPath, 'utf-8').toString().trim();\n                } else {\n                    throw new Error('Unable to load previous source map: ' +\n                    prevPath.toString());\n                }\n            } else if ( prev instanceof mozilla.SourceMapConsumer ) {\n                return mozilla.SourceMapGenerator\n                    .fromSourceMap(prev).toString();\n            } else if ( prev instanceof mozilla.SourceMapGenerator ) {\n                return prev.toString();\n            } else if ( this.isMap(prev) ) {\n                return JSON.stringify(prev);\n            } else {\n                throw new Error('Unsupported previous source map format: ' +\n                    prev.toString());\n            }\n\n        } else if ( this.inline ) {\n            return this.decodeInline(this.annotation);\n\n        } else if ( this.annotation ) {\n            let map = this.annotation;\n            if ( file ) map = path.join(path.dirname(file), map);\n\n            this.root = path.dirname(map);\n            if ( fs.existsSync && fs.existsSync(map) ) {\n                return fs.readFileSync(map, 'utf-8').toString().trim();\n            } else {\n                return false;\n            }\n        }\n    }\n\n    isMap(map) {\n        if ( typeof map !== 'object' ) return false;\n        return typeof map.mappings === 'string' ||\n               typeof map._mappings === 'string';\n    }\n}\n\nexport default PreviousMap;\n"]}