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