first commit

build/node_modules/css-tree/lib/utils/clone.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var List = require('./list');
+
+module.exports = function clone(node) {
+    var result = {};
+
+    for (var key in node) {
+        var value = node[key];
+
+        if (value) {
+            if (Array.isArray(value)) {
+                value = value.slice(0);
+            } else if (value instanceof List) {
+                value = new List().fromArray(value.map(clone));
+            } else if (value.constructor === Object) {
+                value = clone(value);
+            }
+        }
+
+        result[key] = value;
+    }
+
+    return result;
+};

build/node_modules/css-tree/lib/utils/createCustomError.js

@@ -0,0 +1,17 @@
+module.exports = function createCustomError(name, message) {
+    // use Object.create(), because some VMs prevent setting line/column otherwise
+    // (iOS Safari 10 even throws an exception)
+    var error = Object.create(SyntaxError.prototype);
+    var errorStack = new Error();
+
+    error.name = name;
+    error.message = message;
+
+    Object.defineProperty(error, 'stack', {
+        get: function() {
+            return (errorStack.stack || '').replace(/^(.+\n){1,3}/, name + ': ' + message + '\n');
+        }
+    });
+
+    return error;
+};

build/node_modules/css-tree/lib/utils/list.js

@@ -0,0 +1,488 @@
+'use strict';
+
+//
+//            item        item        item        item
+//          /------\    /------\    /------\    /------\
+//          | data |    | data |    | data |    | data |
+//  null <--+-prev |<---+-prev |<---+-prev |<---+-prev |
+//          | next-+--->| next-+--->| next-+--->| next-+--> null
+//          \------/    \------/    \------/    \------/
+//             ^                                    ^
+//             |                list                |
+//             |              /------\              |
+//             \--------------+-head |              |
+//                            | tail-+--------------/
+//                            \------/
+//
+
+function createItem(data) {
+    return {
+        prev: null,
+        next: null,
+        data: data
+    };
+}
+
+var cursors = null;
+var List = function() {
+    this.cursor = null;
+    this.head = null;
+    this.tail = null;
+};
+
+List.createItem = createItem;
+List.prototype.createItem = createItem;
+
+List.prototype.getSize = function() {
+    var size = 0;
+    var cursor = this.head;
+
+    while (cursor) {
+        size++;
+        cursor = cursor.next;
+    }
+
+    return size;
+};
+
+List.prototype.fromArray = function(array) {
+    var cursor = null;
+
+    this.head = null;
+
+    for (var i = 0; i < array.length; i++) {
+        var item = createItem(array[i]);
+
+        if (cursor !== null) {
+            cursor.next = item;
+        } else {
+            this.head = item;
+        }
+
+        item.prev = cursor;
+        cursor = item;
+    }
+
+    this.tail = cursor;
+
+    return this;
+};
+
+List.prototype.toArray = function() {
+    var cursor = this.head;
+    var result = [];
+
+    while (cursor) {
+        result.push(cursor.data);
+        cursor = cursor.next;
+    }
+
+    return result;
+};
+
+List.prototype.toJSON = List.prototype.toArray;
+
+List.prototype.isEmpty = function() {
+    return this.head === null;
+};
+
+List.prototype.first = function() {
+    return this.head && this.head.data;
+};
+
+List.prototype.last = function() {
+    return this.tail && this.tail.data;
+};
+
+function allocateCursor(node, prev, next) {
+    var cursor;
+
+    if (cursors !== null) {
+        cursor = cursors;
+        cursors = cursors.cursor;
+        cursor.prev = prev;
+        cursor.next = next;
+        cursor.cursor = node.cursor;
+    } else {
+        cursor = {
+            prev: prev,
+            next: next,
+            cursor: node.cursor
+        };
+    }
+
+    node.cursor = cursor;
+
+    return cursor;
+}
+
+function releaseCursor(node) {
+    var cursor = node.cursor;
+
+    node.cursor = cursor.cursor;
+    cursor.prev = null;
+    cursor.next = null;
+    cursor.cursor = cursors;
+    cursors = cursor;
+}
+
+List.prototype.each = function(fn, context) {
+    var item;
+
+    if (context === undefined) {
+        context = this;
+    }
+
+    // push cursor
+    var cursor = allocateCursor(this, null, this.head);
+
+    while (cursor.next !== null) {
+        item = cursor.next;
+        cursor.next = item.next;
+
+        fn.call(context, item.data, item, this);
+    }
+
+    // pop cursor
+    releaseCursor(this);
+};
+
+List.prototype.eachRight = function(fn, context) {
+    var item;
+
+    if (context === undefined) {
+        context = this;
+    }
+
+    // push cursor
+    var cursor = allocateCursor(this, this.tail, null);
+
+    while (cursor.prev !== null) {
+        item = cursor.prev;
+        cursor.prev = item.prev;
+
+        fn.call(context, item.data, item, this);
+    }
+
+    // pop cursor
+    releaseCursor(this);
+};
+
+List.prototype.nextUntil = function(start, fn, context) {
+    if (start === null) {
+        return;
+    }
+
+    var item;
+
+    if (context === undefined) {
+        context = this;
+    }
+
+    // push cursor
+    var cursor = allocateCursor(this, null, start);
+
+    while (cursor.next !== null) {
+        item = cursor.next;
+        cursor.next = item.next;
+
+        if (fn.call(context, item.data, item, this)) {
+            break;
+        }
+    }
+
+    // pop cursor
+    releaseCursor(this);
+};
+
+List.prototype.prevUntil = function(start, fn, context) {
+    if (start === null) {
+        return;
+    }
+
+    var item;
+
+    if (context === undefined) {
+        context = this;
+    }
+
+    // push cursor
+    var cursor = allocateCursor(this, start, null);
+
+    while (cursor.prev !== null) {
+        item = cursor.prev;
+        cursor.prev = item.prev;
+
+        if (fn.call(context, item.data, item, this)) {
+            break;
+        }
+    }
+
+    // pop cursor
+    releaseCursor(this);
+};
+
+List.prototype.some = function(fn, context) {
+    var cursor = this.head;
+
+    if (context === undefined) {
+        context = this;
+    }
+
+    while (cursor !== null) {
+        if (fn.call(context, cursor.data, cursor, this)) {
+            return true;
+        }
+
+        cursor = cursor.next;
+    }
+
+    return false;
+};
+
+List.prototype.map = function(fn, context) {
+    var result = [];
+    var cursor = this.head;
+
+    if (context === undefined) {
+        context = this;
+    }
+
+    while (cursor !== null) {
+        result.push(fn.call(context, cursor.data, cursor, this));
+        cursor = cursor.next;
+    }
+
+    return result;
+};
+
+List.prototype.clear = function() {
+    this.head = null;
+    this.tail = null;
+};
+
+List.prototype.copy = function() {
+    var result = new List();
+    var cursor = this.head;
+
+    while (cursor !== null) {
+        result.insert(createItem(cursor.data));
+        cursor = cursor.next;
+    }
+
+    return result;
+};
+
+List.prototype.updateCursors = function(prevOld, prevNew, nextOld, nextNew) {
+    var cursor = this.cursor;
+
+    while (cursor !== null) {
+        if (cursor.prev === prevOld) {
+            cursor.prev = prevNew;
+        }
+
+        if (cursor.next === nextOld) {
+            cursor.next = nextNew;
+        }
+
+        cursor = cursor.cursor;
+    }
+};
+
+List.prototype.prepend = function(item) {
+    //      head
+    //    ^
+    // item
+    this.updateCursors(null, item, this.head, item);
+
+    // insert to the beginning of the list
+    if (this.head !== null) {
+        // new item <- first item
+        this.head.prev = item;
+
+        // new item -> first item
+        item.next = this.head;
+    } else {
+        // if list has no head, then it also has no tail
+        // in this case tail points to the new item
+        this.tail = item;
+    }
+
+    // head always points to new item
+    this.head = item;
+
+    return this;
+};
+
+List.prototype.prependData = function(data) {
+    return this.prepend(createItem(data));
+};
+
+List.prototype.append = function(item) {
+    // tail
+    //      ^
+    //      item
+    this.updateCursors(this.tail, item, null, item);
+
+    // insert to the ending of the list
+    if (this.tail !== null) {
+        // last item -> new item
+        this.tail.next = item;
+
+        // last item <- new item
+        item.prev = this.tail;
+    } else {
+        // if list has no tail, then it also has no head
+        // in this case head points to new item
+        this.head = item;
+    }
+
+    // tail always points to new item
+    this.tail = item;
+
+    return this;
+};
+
+List.prototype.appendData = function(data) {
+    return this.append(createItem(data));
+};
+
+List.prototype.insert = function(item, before) {
+    if (before !== undefined && before !== null) {
+        // prev   before
+        //      ^
+        //     item
+        this.updateCursors(before.prev, item, before, item);
+
+        if (before.prev === null) {
+            // insert to the beginning of list
+            if (this.head !== before) {
+                throw new Error('before doesn\'t belong to list');
+            }
+
+            // since head points to before therefore list doesn't empty
+            // no need to check tail
+            this.head = item;
+            before.prev = item;
+            item.next = before;
+
+            this.updateCursors(null, item);
+        } else {
+
+            // insert between two items
+            before.prev.next = item;
+            item.prev = before.prev;
+
+            before.prev = item;
+            item.next = before;
+        }
+    } else {
+        this.append(item);
+    }
+};
+
+List.prototype.insertData = function(data, before) {
+    this.insert(createItem(data), before);
+};
+
+List.prototype.remove = function(item) {
+    //      item
+    //       ^
+    // prev     next
+    this.updateCursors(item, item.prev, item, item.next);
+
+    if (item.prev !== null) {
+        item.prev.next = item.next;
+    } else {
+        if (this.head !== item) {
+            throw new Error('item doesn\'t belong to list');
+        }
+
+        this.head = item.next;
+    }
+
+    if (item.next !== null) {
+        item.next.prev = item.prev;
+    } else {
+        if (this.tail !== item) {
+            throw new Error('item doesn\'t belong to list');
+        }
+
+        this.tail = item.prev;
+    }
+
+    item.prev = null;
+    item.next = null;
+
+    return item;
+};
+
+List.prototype.appendList = function(list) {
+    // ignore empty lists
+    if (list.head === null) {
+        return;
+    }
+
+    this.updateCursors(this.tail, list.tail, null, list.head);
+
+    // insert to end of the list
+    if (this.tail !== null) {
+        // if destination list has a tail, then it also has a head,
+        // but head doesn't change
+
+        // dest tail -> source head
+        this.tail.next = list.head;
+
+        // dest tail <- source head
+        list.head.prev = this.tail;
+    } else {
+        // if list has no a tail, then it also has no a head
+        // in this case points head to new item
+        this.head = list.head;
+    }
+
+    // tail always start point to new item
+    this.tail = list.tail;
+
+    list.head = null;
+    list.tail = null;
+};
+
+List.prototype.insertList = function(list, before) {
+    if (before !== undefined && before !== null) {
+        // ignore empty lists
+        if (list.head === null) {
+            return;
+        }
+
+        this.updateCursors(before.prev, list.tail, before, list.head);
+
+        // insert in the middle of dist list
+        if (before.prev !== null) {
+            // before.prev <-> list.head
+            before.prev.next = list.head;
+            list.head.prev = before.prev;
+        } else {
+            this.head = list.head;
+        }
+
+        before.prev = list.tail;
+        list.tail.next = before;
+
+        list.head = null;
+        list.tail = null;
+    } else {
+        this.appendList(list);
+    }
+};
+
+List.prototype.replace = function(oldItem, newItemOrList) {
+    if ('head' in newItemOrList) {
+        this.insertList(newItemOrList, oldItem);
+    } else {
+        this.insert(newItemOrList, oldItem);
+    }
+    this.remove(oldItem);
+};
+
+module.exports = List;

build/node_modules/css-tree/lib/utils/names.js

@@ -0,0 +1,88 @@
+'use strict';
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var keywords = Object.create(null);
+var properties = Object.create(null);
+var HYPHENMINUS = 45; // '-'.charCodeAt()
+
+function isCustomProperty(str, offset) {
+    return str.length - offset >= 2 &&
+           str.charCodeAt(offset) === HYPHENMINUS &&
+           str.charCodeAt(offset + 1) === HYPHENMINUS;
+}
+
+function getVendorPrefix(str, offset) {
+    if (str.charCodeAt(offset) === HYPHENMINUS) {
+        // vendor should contain at least one letter
+        var secondDashIndex = str.indexOf('-', offset + 2);
+
+        if (secondDashIndex !== -1) {
+            return str.substring(offset, secondDashIndex + 1);
+        }
+    }
+
+    return '';
+}
+
+function getKeywordInfo(keyword) {
+    if (hasOwnProperty.call(keywords, keyword)) {
+        return keywords[keyword];
+    }
+
+    var name = keyword.toLowerCase();
+
+    if (hasOwnProperty.call(keywords, name)) {
+        return keywords[keyword] = keywords[name];
+    }
+
+    var vendor = !isCustomProperty(name, 0) ? getVendorPrefix(name, 0) : '';
+
+    return keywords[keyword] = Object.freeze({
+        vendor: vendor,
+        prefix: vendor,
+        name: name.substr(vendor.length)
+    });
+}
+
+function getPropertyInfo(property) {
+    if (hasOwnProperty.call(properties, property)) {
+        return properties[property];
+    }
+
+    var name = property;
+    var hack = property[0];
+
+    if (hack === '/') {
+        hack = property[1] === '/' ? '//' : '/';
+    } else if (hack !== '_' &&
+               hack !== '*' &&
+               hack !== '$' &&
+               hack !== '#' &&
+               hack !== '+') {
+        hack = '';
+    }
+
+    var custom = isCustomProperty(name, hack.length);
+
+    if (!custom) {
+        name = name.toLowerCase();
+        if (hasOwnProperty.call(properties, name)) {
+            return properties[property] = properties[name];
+        }
+    }
+
+    var vendor = !custom ? getVendorPrefix(name, hack.length) : '';
+
+    return properties[property] = Object.freeze({
+        hack: hack,
+        vendor: vendor,
+        prefix: hack + vendor,
+        name: name.substr(hack.length + vendor.length),
+        custom: custom
+    });
+}
+
+module.exports = {
+    keyword: getKeywordInfo,
+    property: getPropertyInfo
+};