nuxt-ignis 0.4.0 → 0.5.0-rc.1

package/.output/server/node_modules/.nitro/css-tree@2.3.1/cjs/utils/List.cjs

@@ -0,0 +1,473 @@
+'use strict';
+
+//
+//                              list
+//                            ┌──────┐
+//             ┌──────────────┼─head │
+//             │              │ tail─┼──────────────┐
+//             │              └──────┘              │
+//             ▼                                    ▼
+//            item        item        item        item
+//          ┌──────┐    ┌──────┐    ┌──────┐    ┌──────┐
+//  null ◀──┼─prev │◀───┼─prev │◀───┼─prev │◀───┼─prev │
+//          │ next─┼───▶│ next─┼───▶│ next─┼───▶│ next─┼──▶ null
+//          ├──────┤    ├──────┤    ├──────┤    ├──────┤
+//          │ data │    │ data │    │ data │    │ data │
+//          └──────┘    └──────┘    └──────┘    └──────┘
+//
+
+let releasedCursors = null;
+
+class List {
+    static createItem(data) {
+        return {
+            prev: null,
+            next: null,
+            data
+        };
+    }
+
+    constructor() {
+        this.head = null;
+        this.tail = null;
+        this.cursor = null;
+    }
+    createItem(data) {
+        return List.createItem(data);
+    }
+
+    // cursor helpers
+    allocateCursor(prev, next) {
+        let cursor;
+
+        if (releasedCursors !== null) {
+            cursor = releasedCursors;
+            releasedCursors = releasedCursors.cursor;
+            cursor.prev = prev;
+            cursor.next = next;
+            cursor.cursor = this.cursor;
+        } else {
+            cursor = {
+                prev,
+                next,
+                cursor: this.cursor
+            };
+        }
+
+        this.cursor = cursor;
+
+        return cursor;
+    }
+    releaseCursor() {
+        const { cursor } = this;
+
+        this.cursor = cursor.cursor;
+        cursor.prev = null;
+        cursor.next = null;
+        cursor.cursor = releasedCursors;
+        releasedCursors = cursor;
+    }
+    updateCursors(prevOld, prevNew, nextOld, nextNew) {
+        let { cursor } = this;
+
+        while (cursor !== null) {
+            if (cursor.prev === prevOld) {
+                cursor.prev = prevNew;
+            }
+
+            if (cursor.next === nextOld) {
+                cursor.next = nextNew;
+            }
+
+            cursor = cursor.cursor;
+        }
+    }
+    *[Symbol.iterator]() {
+        for (let cursor = this.head; cursor !== null; cursor = cursor.next) {
+            yield cursor.data;
+        }
+    }
+
+    // getters
+    get size() {
+        let size = 0;
+
+        for (let cursor = this.head; cursor !== null; cursor = cursor.next) {
+            size++;
+        }
+
+        return size;
+    }
+    get isEmpty() {
+        return this.head === null;
+    }
+    get first() {
+        return this.head && this.head.data;
+    }
+    get last() {
+        return this.tail && this.tail.data;
+    }
+
+    // convertors
+    fromArray(array) {
+        let cursor = null;
+        this.head = null;
+
+        for (let data of array) {
+            const item = List.createItem(data);
+
+            if (cursor !== null) {
+                cursor.next = item;
+            } else {
+                this.head = item;
+            }
+
+            item.prev = cursor;
+            cursor = item;
+        }
+
+        this.tail = cursor;
+        return this;
+    }
+    toArray() {
+        return [...this];
+    }
+    toJSON() {
+        return [...this];
+    }
+
+    // array-like methods
+    forEach(fn, thisArg = this) {
+        // push cursor
+        const cursor = this.allocateCursor(null, this.head);
+
+        while (cursor.next !== null) {
+            const item = cursor.next;
+            cursor.next = item.next;
+            fn.call(thisArg, item.data, item, this);
+        }
+
+        // pop cursor
+        this.releaseCursor();
+    }
+    forEachRight(fn, thisArg = this) {
+        // push cursor
+        const cursor = this.allocateCursor(this.tail, null);
+
+        while (cursor.prev !== null) {
+            const item = cursor.prev;
+            cursor.prev = item.prev;
+            fn.call(thisArg, item.data, item, this);
+        }
+
+        // pop cursor
+        this.releaseCursor();
+    }
+    reduce(fn, initialValue, thisArg = this) {
+        // push cursor
+        let cursor = this.allocateCursor(null, this.head);
+        let acc = initialValue;
+        let item;
+
+        while (cursor.next !== null) {
+            item = cursor.next;
+            cursor.next = item.next;
+
+            acc = fn.call(thisArg, acc, item.data, item, this);
+        }
+
+        // pop cursor
+        this.releaseCursor();
+
+        return acc;
+    }
+    reduceRight(fn, initialValue, thisArg = this) {
+        // push cursor
+        let cursor = this.allocateCursor(this.tail, null);
+        let acc = initialValue;
+        let item;
+
+        while (cursor.prev !== null) {
+            item = cursor.prev;
+            cursor.prev = item.prev;
+
+            acc = fn.call(thisArg, acc, item.data, item, this);
+        }
+
+        // pop cursor
+        this.releaseCursor();
+
+        return acc;
+    }
+    some(fn, thisArg = this) {
+        for (let cursor = this.head; cursor !== null; cursor = cursor.next) {
+            if (fn.call(thisArg, cursor.data, cursor, this)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+    map(fn, thisArg = this) {
+        const result = new List();
+
+        for (let cursor = this.head; cursor !== null; cursor = cursor.next) {
+            result.appendData(fn.call(thisArg, cursor.data, cursor, this));
+        }
+
+        return result;
+    }
+    filter(fn, thisArg = this) {
+        const result = new List();
+
+        for (let cursor = this.head; cursor !== null; cursor = cursor.next) {
+            if (fn.call(thisArg, cursor.data, cursor, this)) {
+                result.appendData(cursor.data);
+            }
+        }
+
+        return result;
+    }
+
+    nextUntil(start, fn, thisArg = this) {
+        if (start === null) {
+            return;
+        }
+
+        // push cursor
+        const cursor = this.allocateCursor(null, start);
+
+        while (cursor.next !== null) {
+            const item = cursor.next;
+            cursor.next = item.next;
+            if (fn.call(thisArg, item.data, item, this)) {
+                break;
+            }
+        }
+
+        // pop cursor
+        this.releaseCursor();
+    }
+    prevUntil(start, fn, thisArg = this) {
+        if (start === null) {
+            return;
+        }
+
+        // push cursor
+        const cursor = this.allocateCursor(start, null);
+
+        while (cursor.prev !== null) {
+            const item = cursor.prev;
+            cursor.prev = item.prev;
+            if (fn.call(thisArg, item.data, item, this)) {
+                break;
+            }
+        }
+
+        // pop cursor
+        this.releaseCursor();
+    }
+
+    // mutation
+    clear() {
+        this.head = null;
+        this.tail = null;
+    }
+    copy() {
+        const result = new List();
+
+        for (let data of this) {
+            result.appendData(data);
+        }
+
+        return result;
+    }
+    prepend(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;
+    }
+    prependData(data) {
+        return this.prepend(List.createItem(data));
+    }
+    append(item) {
+        return this.insert(item);
+    }
+    appendData(data) {
+        return this.insert(List.createItem(data));
+    }
+    insert(item, before = null) {
+        if (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 {
+            // 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;
+    }
+    insertData(data, before) {
+        return this.insert(List.createItem(data), before);
+    }
+    remove(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;
+    }
+    push(data) {
+        this.insert(List.createItem(data));
+    }
+    pop() {
+        return this.tail !== null ? this.remove(this.tail) : null;
+    }
+    unshift(data) {
+        this.prepend(List.createItem(data));
+    }
+    shift() {
+        return this.head !== null ? this.remove(this.head) : null;
+    }
+    prependList(list) {
+        return this.insertList(list, this.head);
+    }
+    appendList(list) {
+        return this.insertList(list);
+    }
+    insertList(list, before) {
+        // ignore empty lists
+        if (list.head === null) {
+            return this;
+        }
+
+        if (before !== undefined && before !== null) {
+            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;
+        } else {
+            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;
+        return this;
+    }
+    replace(oldItem, newItemOrList) {
+        if ('head' in newItemOrList) {
+            this.insertList(newItemOrList, oldItem);
+        } else {
+            this.insert(newItemOrList, oldItem);
+        }
+
+        this.remove(oldItem);
+    }
+}
+
+exports.List = List;

package/.output/server/node_modules/.nitro/css-tree@2.3.1/cjs/utils/clone.cjs

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

package/.output/server/node_modules/.nitro/css-tree@2.3.1/cjs/utils/create-custom-error.cjs

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

package/.output/server/node_modules/.nitro/css-tree@2.3.1/cjs/utils/ident.cjs

@@ -0,0 +1,102 @@
+'use strict';
+
+const charCodeDefinitions = require('../tokenizer/char-code-definitions.cjs');
+const utils = require('../tokenizer/utils.cjs');
+
+const REVERSE_SOLIDUS = 0x005c; // U+005C REVERSE SOLIDUS (\)
+
+function decode(str) {
+    const end = str.length - 1;
+    let decoded = '';
+
+    for (let i = 0; i < str.length; i++) {
+        let code = str.charCodeAt(i);
+
+        if (code === REVERSE_SOLIDUS) {
+            // special case at the ending
+            if (i === end) {
+                // if the next input code point is EOF, do nothing
+                break;
+            }
+
+            code = str.charCodeAt(++i);
+
+            // consume escaped
+            if (charCodeDefinitions.isValidEscape(REVERSE_SOLIDUS, code)) {
+                const escapeStart = i - 1;
+                const escapeEnd = utils.consumeEscaped(str, escapeStart);
+
+                i = escapeEnd - 1;
+                decoded += utils.decodeEscaped(str.substring(escapeStart + 1, escapeEnd));
+            } else {
+                // \r\n
+                if (code === 0x000d && str.charCodeAt(i + 1) === 0x000a) {
+                    i++;
+                }
+            }
+        } else {
+            decoded += str[i];
+        }
+    }
+
+    return decoded;
+}
+
+// https://drafts.csswg.org/cssom/#serialize-an-identifier
+// § 2.1. Common Serializing Idioms
+function encode(str) {
+    let encoded = '';
+
+    // If the character is the first character and is a "-" (U+002D),
+    // and there is no second character, then the escaped character.
+    // Note: That's means a single dash string "-" return as escaped dash,
+    // so move the condition out of the main loop
+    if (str.length === 1 && str.charCodeAt(0) === 0x002D) {
+        return '\\-';
+    }
+
+    // To serialize an identifier means to create a string represented
+    // by the concatenation of, for each character of the identifier:
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+
+        // If the character is NULL (U+0000), then the REPLACEMENT CHARACTER (U+FFFD).
+        if (code === 0x0000) {
+            encoded += '\uFFFD';
+            continue;
+        }
+
+        if (
+            // If the character is in the range [\1-\1f] (U+0001 to U+001F) or is U+007F ...
+            // Note: Do not compare with 0x0001 since 0x0000 is precessed before
+            code <= 0x001F || code === 0x007F ||
+            // [or] ... is in the range [0-9] (U+0030 to U+0039),
+            (code >= 0x0030 && code <= 0x0039 && (
+                // If the character is the first character ...
+                i === 0 ||
+                // If the character is the second character ... and the first character is a "-" (U+002D)
+                i === 1 && str.charCodeAt(0) === 0x002D
+            ))
+        ) {
+            // ... then the character escaped as code point.
+            encoded += '\\' + code.toString(16) + ' ';
+            continue;
+        }
+
+        // If the character is not handled by one of the above rules and is greater
+        // than or equal to U+0080, is "-" (U+002D) or "_" (U+005F), or is in one
+        // of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to U+005A),
+        // or \[a-z] (U+0061 to U+007A), then the character itself.
+        if (charCodeDefinitions.isName(code)) {
+            encoded += str.charAt(i);
+        } else {
+            // Otherwise, the escaped character.
+            encoded += '\\' + str.charAt(i);
+        }
+    }
+
+    return encoded;
+}
+
+exports.decode = decode;
+exports.encode = encode;