1 files changed, 204 insertions, 0 deletions
diff --git a/node_modules/postcss/lib/input.js b/node_modules/postcss/lib/input.js
new file mode 100644
index 0000000..b23e060
--- /dev/null
+++ b/node_modules/postcss/lib/input.js
@@ -0,0 +1,204 @@
+'use strict';
+
+exports.__esModule = true;
+
+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; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _cssSyntaxError = require('./css-syntax-error');
+
+var _cssSyntaxError2 = _interopRequireDefault(_cssSyntaxError);
+
+var _previousMap = require('./previous-map');
+
+var _previousMap2 = _interopRequireDefault(_previousMap);
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var sequence = 0;
+
+/**
+ * Represents the source CSS.
+ *
+ * @example
+ * const root  = postcss.parse(css, { from: file });
+ * const input = root.source.input;
+ */
+
+var Input = function () {
+
+    /**
+     * @param {string} css    - input CSS source
+     * @param {object} [opts] - {@link Processor#process} options
+     */
+    function Input(css) {
+        var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+        _classCallCheck(this, Input);
+
+        if (css === null || (typeof css === 'undefined' ? 'undefined' : _typeof(css)) === 'object' && !css.toString) {
+            throw new Error('PostCSS received ' + css + ' instead of CSS string');
+        }
+
+        /**
+         * @member {string} - input CSS source
+         *
+         * @example
+         * const input = postcss.parse('a{}', { from: file }).input;
+         * input.css //=> "a{}";
+         */
+        this.css = css.toString();
+
+        if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') {
+            this.css = this.css.slice(1);
+        }
+
+        if (opts.from) {
+            if (/^\w+:\/\//.test(opts.from)) {
+                /**
+                 * @member {string} - The absolute path to the CSS source file
+                 *                    defined with the `from` option.
+                 *
+                 * @example
+                 * const root = postcss.parse(css, { from: 'a.css' });
+                 * root.source.input.file //=> '/home/ai/a.css'
+                 */
+                this.file = opts.from;
+            } else {
+                this.file = _path2.default.resolve(opts.from);
+            }
+        }
+
+        var map = new _previousMap2.default(this.css, opts);
+        if (map.text) {
+            /**
+             * @member {PreviousMap} - The input source map passed from
+             *                         a compilation step before PostCSS
+             *                         (for example, from Sass compiler).
+             *
+             * @example
+             * root.source.input.map.consumer().sources //=> ['a.sass']
+             */
+            this.map = map;
+            var file = map.consumer().file;
+            if (!this.file && file) this.file = this.mapResolve(file);
+        }
+
+        if (!this.file) {
+            sequence += 1;
+            /**
+             * @member {string} - The unique ID of the CSS source. It will be
+             *                    created if `from` option is not provided
+             *                    (because PostCSS does not know the file path).
+             *
+             * @example
+             * const root = postcss.parse(css);
+             * root.source.input.file //=> undefined
+             * root.source.input.id   //=> "<input css 1>"
+             */
+            this.id = '<input css ' + sequence + '>';
+        }
+        if (this.map) this.map.file = this.from;
+    }
+
+    Input.prototype.error = function error(message, line, column) {
+        var opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+        var result = void 0;
+        var origin = this.origin(line, column);
+        if (origin) {
+            result = new _cssSyntaxError2.default(message, origin.line, origin.column, origin.source, origin.file, opts.plugin);
+        } else {
+            result = new _cssSyntaxError2.default(message, line, column, this.css, this.file, opts.plugin);
+        }
+
+        result.input = { line: line, column: column, source: this.css };
+        if (this.file) result.input.file = this.file;
+
+        return result;
+    };
+
+    /**
+     * Reads the input source map and returns a symbol position
+     * in the input source (e.g., in a Sass file that was compiled
+     * to CSS before being passed to PostCSS).
+     *
+     * @param {number} line   - line in input CSS
+     * @param {number} column - column in input CSS
+     *
+     * @return {filePosition} position in input source
+     *
+     * @example
+     * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 }
+     */
+
+
+    Input.prototype.origin = function origin(line, column) {
+        if (!this.map) return false;
+        var consumer = this.map.consumer();
+
+        var from = consumer.originalPositionFor({ line: line, column: column });
+        if (!from.source) return false;
+
+        var result = {
+            file: this.mapResolve(from.source),
+            line: from.line,
+            column: from.column
+        };
+
+        var source = consumer.sourceContentFor(from.source);
+        if (source) result.source = source;
+
+        return result;
+    };
+
+    Input.prototype.mapResolve = function mapResolve(file) {
+        if (/^\w+:\/\//.test(file)) {
+            return file;
+        } else {
+            return _path2.default.resolve(this.map.consumer().sourceRoot || '.', file);
+        }
+    };
+
+    /**
+     * The CSS source identifier. Contains {@link Input#file} if the user
+     * set the `from` option, or {@link Input#id} if they did not.
+     * @type {string}
+     *
+     * @example
+     * const root = postcss.parse(css, { from: 'a.css' });
+     * root.source.input.from //=> "/home/ai/a.css"
+     *
+     * const root = postcss.parse(css);
+     * root.source.input.from //=> "<input css 1>"
+     */
+
+
+    _createClass(Input, [{
+        key: 'from',
+        get: function get() {
+            return this.file || this.id;
+        }
+    }]);
+
+    return Input;
+}();
+
+exports.default = Input;
+
+/**
+ * @typedef  {object} filePosition
+ * @property {string} file   - path to file
+ * @property {number} line   - source line in file
+ * @property {number} column - source column in file
+ */
+
+module.exports = exports['default'];
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["input.es6"],"names":["sequence","Input","css","opts","toString","Error","slice","from","test","file","path","resolve","map","PreviousMap","text","consumer","mapResolve","id","error","message","line","column","result","origin","CssSyntaxError","source","plugin","input","originalPositionFor","sourceContentFor","sourceRoot"],"mappings":"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","file":"input.js","sourcesContent":["import CssSyntaxError from './css-syntax-error';\nimport PreviousMap    from './previous-map';\n\nimport path from 'path';\n\nlet sequence = 0;\n\n/**\n * Represents the source CSS.\n *\n * @example\n * const root  = postcss.parse(css, { from: file });\n * const input = root.source.input;\n */\nclass Input {\n\n    /**\n     * @param {string} css    - input CSS source\n     * @param {object} [opts] - {@link Processor#process} options\n     */\n    constructor(css, opts = { }) {\n        if ( css === null || typeof css === 'object' && !css.toString ) {\n            throw new Error(`PostCSS received ${ css } instead of CSS string`);\n        }\n\n        /**\n         * @member {string} - input CSS source\n         *\n         * @example\n         * const input = postcss.parse('a{}', { from: file }).input;\n         * input.css //=> \"a{}\";\n         */\n        this.css = css.toString();\n\n        if ( this.css[0] === '\\uFEFF' || this.css[0] === '\\uFFFE' ) {\n            this.css = this.css.slice(1);\n        }\n\n        if ( opts.from ) {\n            if ( /^\\w+:\\/\\//.test(opts.from) ) {\n                /**\n                 * @member {string} - The absolute path to the CSS source file\n                 *                    defined with the `from` option.\n                 *\n                 * @example\n                 * const root = postcss.parse(css, { from: 'a.css' });\n                 * root.source.input.file //=> '/home/ai/a.css'\n                 */\n                this.file = opts.from;\n            } else {\n                this.file = path.resolve(opts.from);\n            }\n        }\n\n        let map = new PreviousMap(this.css, opts);\n        if ( map.text ) {\n            /**\n             * @member {PreviousMap} - The input source map passed from\n             *                         a compilation step before PostCSS\n             *                         (for example, from Sass compiler).\n             *\n             * @example\n             * root.source.input.map.consumer().sources //=> ['a.sass']\n             */\n            this.map = map;\n            let file = map.consumer().file;\n            if ( !this.file && file ) this.file = this.mapResolve(file);\n        }\n\n        if ( !this.file ) {\n            sequence += 1;\n            /**\n             * @member {string} - The unique ID of the CSS source. It will be\n             *                    created if `from` option is not provided\n             *                    (because PostCSS does not know the file path).\n             *\n             * @example\n             * const root = postcss.parse(css);\n             * root.source.input.file //=> undefined\n             * root.source.input.id   //=> \"<input css 1>\"\n             */\n            this.id   = '<input css ' + sequence + '>';\n        }\n        if ( this.map ) this.map.file = this.from;\n    }\n\n    error(message, line, column, opts = { }) {\n        let result;\n        let origin = this.origin(line, column);\n        if ( origin ) {\n            result = new CssSyntaxError(message, origin.line, origin.column,\n                origin.source, origin.file, opts.plugin);\n        } else {\n            result = new CssSyntaxError(message, line, column,\n                this.css, this.file, opts.plugin);\n        }\n\n        result.input = { line, column, source: this.css };\n        if ( this.file ) result.input.file = this.file;\n\n        return result;\n    }\n\n    /**\n     * Reads the input source map and returns a symbol position\n     * in the input source (e.g., in a Sass file that was compiled\n     * to CSS before being passed to PostCSS).\n     *\n     * @param {number} line   - line in input CSS\n     * @param {number} column - column in input CSS\n     *\n     * @return {filePosition} position in input source\n     *\n     * @example\n     * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 }\n     */\n    origin(line, column) {\n        if ( !this.map ) return false;\n        let consumer = this.map.consumer();\n\n        let from = consumer.originalPositionFor({ line, column });\n        if ( !from.source ) return false;\n\n        let result = {\n            file:   this.mapResolve(from.source),\n            line:   from.line,\n            column: from.column\n        };\n\n        let source = consumer.sourceContentFor(from.source);\n        if ( source ) result.source = source;\n\n        return result;\n    }\n\n    mapResolve(file) {\n        if ( /^\\w+:\\/\\//.test(file) ) {\n            return file;\n        } else {\n            return path.resolve(this.map.consumer().sourceRoot || '.', file);\n        }\n    }\n\n    /**\n     * The CSS source identifier. Contains {@link Input#file} if the user\n     * set the `from` option, or {@link Input#id} if they did not.\n     * @type {string}\n     *\n     * @example\n     * const root = postcss.parse(css, { from: 'a.css' });\n     * root.source.input.from //=> \"/home/ai/a.css\"\n     *\n     * const root = postcss.parse(css);\n     * root.source.input.from //=> \"<input css 1>\"\n     */\n    get from() {\n        return this.file || this.id;\n    }\n\n}\n\nexport default Input;\n\n/**\n * @typedef  {object} filePosition\n * @property {string} file   - path to file\n * @property {number} line   - source line in file\n * @property {number} column - source column in file\n */\n"]}