Actualizacion maquina principal

[dotfiles/.git] / .config / coc / extensions / node_modules / coc-prettier / node_modules / sugarss / stringifier.js

diff --git a/.config/coc/extensions/node_modules/coc-prettier/node_modules/sugarss/stringifier.js b/.config/coc/extensions/node_modules/coc-prettier/node_modules/sugarss/stringifier.js
new file mode 100644 (file)
index 0000000..d9bd4f8
--- /dev/null
+++ b/.config/coc/extensions/node_modules/coc-prettier/node_modules/sugarss/stringifier.js
@@ -0,0 +1,127 @@
+'use strict';
+
+exports.__esModule = true;
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var defaultRaw = {
+    colon: ': ',
+    indent: '  ',
+    commentLeft: ' ',
+    commentRight: ' '
+};
+
+var Stringifier = function () {
+    function Stringifier(builder) {
+        _classCallCheck(this, Stringifier);
+
+        this.builder = builder;
+    }
+
+    Stringifier.prototype.stringify = function stringify(node, semicolon) {
+        this[node.type](node, semicolon);
+    };
+
+    Stringifier.prototype.root = function root(node) {
+        this.body(node);
+        if (node.raws.after) this.builder(node.raws.after);
+    };
+
+    Stringifier.prototype.comment = function comment(node) {
+        var left = defaultRaw.commentLeft;
+        var right = defaultRaw.commentRight;
+        if (this.has(node.raws.left)) left = node.raws.left;
+
+        if (node.raws.inline) {
+            if (this.has(node.raws.inlineRight)) {
+                right = node.raws.inlineRight;
+            } else {
+                right = '';
+            }
+            if (node.raws.extraIndent) {
+                this.builder(node.raws.extraIndent);
+            }
+            this.builder('//' + left + node.text + right, node);
+        } else {
+            if (this.has(node.raws.right)) right = node.raws.right;
+            this.builder('/*' + left + node.text + right + '*/', node);
+        }
+    };
+
+    Stringifier.prototype.decl = function decl(node) {
+        var between = node.raws.between || defaultRaw.colon;
+        var string = node.prop + between + this.rawValue(node, 'value');
+
+        if (node.important) {
+            string += node.raws.important || ' !important';
+        }
+
+        this.builder(string, node);
+    };
+
+    Stringifier.prototype.rule = function rule(node) {
+        this.block(node, this.rawValue(node, 'selector'));
+    };
+
+    Stringifier.prototype.atrule = function atrule(node) {
+        var name = '@' + node.name;
+        var params = node.params ? this.rawValue(node, 'params') : '';
+
+        if (this.has(node.raws.afterName)) {
+            name += node.raws.afterName;
+        } else if (params) {
+            name += ' ';
+        }
+
+        this.block(node, name + params);
+    };
+
+    Stringifier.prototype.body = function body(node) {
+        var indent = node.root().raws.indent || defaultRaw.indent;
+
+        for (var i = 0; i < node.nodes.length; i++) {
+            var child = node.nodes[i];
+            var before = child.raws.before.replace(/[^\n]*$/, '') + this.indent(node, indent);
+            if (child.type === 'comment' && child.raws.before.indexOf('\n') === -1) {
+                before = child.raws.before;
+            }
+            if (before) this.builder(before);
+            this.stringify(child);
+        }
+    };
+
+    Stringifier.prototype.block = function block(node, start) {
+        var between = node.raws.sssBetween || '';
+        this.builder(start + between, node, 'start');
+        if (this.has(node.nodes)) this.body(node);
+    };
+
+    Stringifier.prototype.indent = function indent(node, step) {
+        var result = '';
+        while (node.parent) {
+            result += step;
+            node = node.parent;
+        }
+        return result;
+    };
+
+    Stringifier.prototype.has = function has(value) {
+        return typeof value !== 'undefined';
+    };
+
+    Stringifier.prototype.rawValue = function rawValue(node, prop) {
+        var value = node[prop];
+        var raw = node.raws[prop];
+        if (raw && raw.value === value) {
+            return raw.sss || raw.raw;
+        } else {
+            return value;
+        }
+    };
+
+    return Stringifier;
+}();
+
+exports.default = Stringifier;
+module.exports = exports['default'];
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["stringifier.es6"],"names":["defaultRaw","colon","indent","commentLeft","commentRight","Stringifier","builder","stringify","node","semicolon","type","root","body","raws","after","comment","left","right","has","inline","inlineRight","extraIndent","text","decl","between","string","prop","rawValue","important","rule","block","atrule","name","params","afterName","i","nodes","length","child","before","replace","indexOf","start","sssBetween","step","result","parent","value","raw","sss"],"mappings":"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","file":"stringifier.js","sourcesContent":["const defaultRaw = {\n    colon:        ': ',\n    indent:       '  ',\n    commentLeft:  ' ',\n    commentRight: ' '\n};\n\nexport default class Stringifier {\n\n    constructor(builder) {\n        this.builder = builder;\n    }\n\n    stringify(node, semicolon) {\n        this[node.type](node, semicolon);\n    }\n\n    root(node) {\n        this.body(node);\n        if ( node.raws.after ) this.builder(node.raws.after);\n    }\n\n    comment(node) {\n        let left  = defaultRaw.commentLeft;\n        let right = defaultRaw.commentRight;\n        if ( this.has(node.raws.left) ) left = node.raws.left;\n\n        if ( node.raws.inline ) {\n            if ( this.has(node.raws.inlineRight) ) {\n                right = node.raws.inlineRight;\n            } else {\n                right = '';\n            }\n            if ( node.raws.extraIndent ) {\n                this.builder(node.raws.extraIndent);\n            }\n            this.builder('//' + left + node.text + right, node);\n        } else {\n            if ( this.has(node.raws.right) ) right = node.raws.right;\n            this.builder('/*' + left + node.text + right + '*/', node);\n        }\n    }\n\n    decl(node) {\n        let between = node.raws.between || defaultRaw.colon;\n        let string  = node.prop + between + this.rawValue(node, 'value');\n\n        if ( node.important ) {\n            string += node.raws.important || ' !important';\n        }\n\n        this.builder(string, node);\n    }\n\n    rule(node) {\n        this.block(node, this.rawValue(node, 'selector'));\n    }\n\n    atrule(node) {\n        let name   = '@' + node.name;\n        let params = node.params ? this.rawValue(node, 'params') : '';\n\n        if ( this.has(node.raws.afterName) ) {\n            name += node.raws.afterName;\n        } else if ( params ) {\n            name += ' ';\n        }\n\n        this.block(node, name + params);\n    }\n\n    body(node) {\n        let indent = node.root().raws.indent || defaultRaw.indent;\n\n        for ( let i = 0; i < node.nodes.length; i++ ) {\n            let child  = node.nodes[i];\n            let before = child.raws.before.replace(/[^\\n]*$/, '') +\n                         this.indent(node, indent);\n            if ( child.type === 'comment' &&\n                 child.raws.before.indexOf('\\n') === -1 ) {\n                before = child.raws.before;\n            }\n            if ( before ) this.builder(before);\n            this.stringify(child);\n        }\n    }\n\n    block(node, start) {\n        let between = node.raws.sssBetween || '';\n        this.builder(start + between, node, 'start');\n        if ( this.has(node.nodes) ) this.body(node);\n    }\n\n    indent(node, step) {\n        let result = '';\n        while ( node.parent ) {\n            result += step;\n            node = node.parent;\n        }\n        return result;\n    }\n\n    has(value) {\n        return typeof value !== 'undefined';\n    }\n\n    rawValue(node, prop) {\n        let value = node[prop];\n        let raw   = node.raws[prop];\n        if ( raw && raw.value === value ) {\n            return raw.sss || raw.raw;\n        } else {\n            return value;\n        }\n    }\n\n}\n"]}
\ No newline at end of file