aboutsummaryrefslogtreecommitdiff
path: root/node_modules/postcss-value-parser/lib
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/postcss-value-parser/lib')
-rw-r--r--node_modules/postcss-value-parser/lib/index.d.ts172
-rw-r--r--node_modules/postcss-value-parser/lib/index.js28
-rw-r--r--node_modules/postcss-value-parser/lib/parse.js304
-rw-r--r--node_modules/postcss-value-parser/lib/stringify.js48
-rw-r--r--node_modules/postcss-value-parser/lib/unit.js120
-rw-r--r--node_modules/postcss-value-parser/lib/walk.js22
6 files changed, 694 insertions, 0 deletions
diff --git a/node_modules/postcss-value-parser/lib/index.d.ts b/node_modules/postcss-value-parser/lib/index.d.ts
new file mode 100644
index 0000000..36c052c
--- /dev/null
+++ b/node_modules/postcss-value-parser/lib/index.d.ts
@@ -0,0 +1,172 @@
+declare namespace postcssValueParser {
+ interface BaseNode {
+ /**
+ * The offset inside the CSS value at which the node starts
+ */
+ sourceIndex: number;
+
+ /**
+ * The node's characteristic value
+ */
+ value: string;
+ }
+
+ interface ClosableNode {
+ /**
+ * Whether the parsed CSS value ended before the node was properly closed
+ */
+ unclosed?: true;
+ }
+
+ interface AdjacentAwareNode {
+ /**
+ * The token at the start of the node
+ */
+ before: string;
+
+ /**
+ * The token at the end of the node
+ */
+ after: string;
+ }
+
+ interface CommentNode extends BaseNode, ClosableNode {
+ type: "comment";
+ }
+
+ interface DivNode extends BaseNode, AdjacentAwareNode {
+ type: "div";
+ }
+
+ interface FunctionNode extends BaseNode, ClosableNode, AdjacentAwareNode {
+ type: "function";
+
+ /**
+ * Nodes inside the function
+ */
+ nodes: Node[];
+ }
+
+ interface SpaceNode extends BaseNode {
+ type: "space";
+ }
+
+ interface StringNode extends BaseNode, ClosableNode {
+ type: "string";
+
+ /**
+ * The quote type delimiting the string
+ */
+ quote: '"' | "'";
+ }
+
+ interface UnicodeRangeNode extends BaseNode {
+ type: "unicode-range";
+ }
+
+ interface WordNode extends BaseNode {
+ type: "word";
+ }
+
+ /**
+ * Any node parsed from a CSS value
+ */
+ type Node =
+ | CommentNode
+ | DivNode
+ | FunctionNode
+ | SpaceNode
+ | StringNode
+ | UnicodeRangeNode
+ | WordNode;
+
+ interface CustomStringifierCallback {
+ /**
+ * @param node The node to stringify
+ * @returns The serialized CSS representation of the node
+ */
+ (nodes: Node): string;
+ }
+
+ interface WalkCallback {
+ /**
+ * @param node The currently visited node
+ * @param index The index of the node in the series of parsed nodes
+ * @param nodes The series of parsed nodes
+ * @returns Returning `false` will prevent traversal of descendant nodes (only applies if `bubble` was set to `true` in the `walk()` call)
+ */
+ (node: Node, index: number, nodes: Node[]): void | false;
+ }
+
+ /**
+ * A CSS dimension, decomposed into its numeric and unit parts
+ */
+ interface Dimension {
+ number: string;
+ unit: string;
+ }
+
+ /**
+ * A wrapper around a parsed CSS value that allows for inspecting and walking nodes
+ */
+ interface ParsedValue {
+ /**
+ * The series of parsed nodes
+ */
+ nodes: Node[];
+
+ /**
+ * Walk all parsed nodes, applying a callback
+ *
+ * @param callback A visitor callback that will be executed for each node
+ * @param bubble When set to `true`, walking will be done inside-out instead of outside-in
+ */
+ walk(callback: WalkCallback, bubble?: boolean): this;
+ }
+
+ interface ValueParser {
+ /**
+ * Decompose a CSSĀ dimension into its numeric and unit part
+ *
+ * @param value The dimension to decompose
+ * @returns An object representing `number` and `unit` part of the dimension or `false` if the decomposing fails
+ */
+ unit(value: string): Dimension | false;
+
+ /**
+ * Serialize a series of nodes into a CSS value
+ *
+ * @param nodes The nodes to stringify
+ * @param custom A custom stringifier callback
+ * @returns The generated CSS value
+ */
+ stringify(nodes: Node[], custom?: CustomStringifierCallback): string;
+
+ /**
+ * Walk a series of nodes, applying a callback
+ *
+ * @param nodes The nodes to walk
+ * @param callback A visitor callback that will be executed for each node
+ * @param bubble When set to `true`, walking will be done inside-out instead of outside-in
+ */
+ walk(nodes: Node[], callback: WalkCallback, bubble?: boolean): void;
+
+ /**
+ * Parse a CSS value into a series of nodes to operate on
+ *
+ * @param value The value to parse
+ */
+ new (value: string): ParsedValue;
+
+ /**
+ * Parse a CSS value into a series of nodes to operate on
+ *
+ * @param value The value to parse
+ */
+ (value: string): ParsedValue;
+ }
+}
+
+declare const postcssValueParser: postcssValueParser.ValueParser;
+
+export = postcssValueParser;
diff --git a/node_modules/postcss-value-parser/lib/index.js b/node_modules/postcss-value-parser/lib/index.js
new file mode 100644
index 0000000..f9ac0e6
--- /dev/null
+++ b/node_modules/postcss-value-parser/lib/index.js
@@ -0,0 +1,28 @@
+var parse = require("./parse");
+var walk = require("./walk");
+var stringify = require("./stringify");
+
+function ValueParser(value) {
+ if (this instanceof ValueParser) {
+ this.nodes = parse(value);
+ return this;
+ }
+ return new ValueParser(value);
+}
+
+ValueParser.prototype.toString = function() {
+ return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
+};
+
+ValueParser.prototype.walk = function(cb, bubble) {
+ walk(this.nodes, cb, bubble);
+ return this;
+};
+
+ValueParser.unit = require("./unit");
+
+ValueParser.walk = walk;
+
+ValueParser.stringify = stringify;
+
+module.exports = ValueParser;
diff --git a/node_modules/postcss-value-parser/lib/parse.js b/node_modules/postcss-value-parser/lib/parse.js
new file mode 100644
index 0000000..502b5ba
--- /dev/null
+++ b/node_modules/postcss-value-parser/lib/parse.js
@@ -0,0 +1,304 @@
+var openParentheses = "(".charCodeAt(0);
+var closeParentheses = ")".charCodeAt(0);
+var singleQuote = "'".charCodeAt(0);
+var doubleQuote = '"'.charCodeAt(0);
+var backslash = "\\".charCodeAt(0);
+var slash = "/".charCodeAt(0);
+var comma = ",".charCodeAt(0);
+var colon = ":".charCodeAt(0);
+var star = "*".charCodeAt(0);
+var uLower = "u".charCodeAt(0);
+var uUpper = "U".charCodeAt(0);
+var plus = "+".charCodeAt(0);
+var isUnicodeRange = /^[a-f0-9?-]+$/i;
+
+module.exports = function(input) {
+ var tokens = [];
+ var value = input;
+
+ var next,
+ quote,
+ prev,
+ token,
+ escape,
+ escapePos,
+ whitespacePos,
+ parenthesesOpenPos;
+ var pos = 0;
+ var code = value.charCodeAt(pos);
+ var max = value.length;
+ var stack = [{ nodes: tokens }];
+ var balanced = 0;
+ var parent;
+
+ var name = "";
+ var before = "";
+ var after = "";
+
+ while (pos < max) {
+ // Whitespaces
+ if (code <= 32) {
+ next = pos;
+ do {
+ next += 1;
+ code = value.charCodeAt(next);
+ } while (code <= 32);
+ token = value.slice(pos, next);
+
+ prev = tokens[tokens.length - 1];
+ if (code === closeParentheses && balanced) {
+ after = token;
+ } else if (prev && prev.type === "div") {
+ prev.after = token;
+ } else if (
+ code === comma ||
+ code === colon ||
+ (code === slash &&
+ value.charCodeAt(next + 1) !== star &&
+ (!parent ||
+ (parent && parent.type === "function" && parent.value !== "calc")))
+ ) {
+ before = token;
+ } else {
+ tokens.push({
+ type: "space",
+ sourceIndex: pos,
+ value: token
+ });
+ }
+
+ pos = next;
+
+ // Quotes
+ } else if (code === singleQuote || code === doubleQuote) {
+ next = pos;
+ quote = code === singleQuote ? "'" : '"';
+ token = {
+ type: "string",
+ sourceIndex: pos,
+ quote: quote
+ };
+ do {
+ escape = false;
+ next = value.indexOf(quote, next + 1);
+ if (~next) {
+ escapePos = next;
+ while (value.charCodeAt(escapePos - 1) === backslash) {
+ escapePos -= 1;
+ escape = !escape;
+ }
+ } else {
+ value += quote;
+ next = value.length - 1;
+ token.unclosed = true;
+ }
+ } while (escape);
+ token.value = value.slice(pos + 1, next);
+
+ tokens.push(token);
+ pos = next + 1;
+ code = value.charCodeAt(pos);
+
+ // Comments
+ } else if (code === slash && value.charCodeAt(pos + 1) === star) {
+ token = {
+ type: "comment",
+ sourceIndex: pos
+ };
+
+ next = value.indexOf("*/", pos);
+ if (next === -1) {
+ token.unclosed = true;
+ next = value.length;
+ }
+
+ token.value = value.slice(pos + 2, next);
+ tokens.push(token);
+
+ pos = next + 2;
+ code = value.charCodeAt(pos);
+
+ // Operation within calc
+ } else if (
+ (code === slash || code === star) &&
+ parent &&
+ parent.type === "function" &&
+ parent.value === "calc"
+ ) {
+ token = value[pos];
+ tokens.push({
+ type: "word",
+ sourceIndex: pos - before.length,
+ value: token
+ });
+ pos += 1;
+ code = value.charCodeAt(pos);
+
+ // Dividers
+ } else if (code === slash || code === comma || code === colon) {
+ token = value[pos];
+
+ tokens.push({
+ type: "div",
+ sourceIndex: pos - before.length,
+ value: token,
+ before: before,
+ after: ""
+ });
+ before = "";
+
+ pos += 1;
+ code = value.charCodeAt(pos);
+
+ // Open parentheses
+ } else if (openParentheses === code) {
+ // Whitespaces after open parentheses
+ next = pos;
+ do {
+ next += 1;
+ code = value.charCodeAt(next);
+ } while (code <= 32);
+ parenthesesOpenPos = pos;
+ token = {
+ type: "function",
+ sourceIndex: pos - name.length,
+ value: name,
+ before: value.slice(parenthesesOpenPos + 1, next)
+ };
+ pos = next;
+
+ if (name === "url" && code !== singleQuote && code !== doubleQuote) {
+ next -= 1;
+ do {
+ escape = false;
+ next = value.indexOf(")", next + 1);
+ if (~next) {
+ escapePos = next;
+ while (value.charCodeAt(escapePos - 1) === backslash) {
+ escapePos -= 1;
+ escape = !escape;
+ }
+ } else {
+ value += ")";
+ next = value.length - 1;
+ token.unclosed = true;
+ }
+ } while (escape);
+ // Whitespaces before closed
+ whitespacePos = next;
+ do {
+ whitespacePos -= 1;
+ code = value.charCodeAt(whitespacePos);
+ } while (code <= 32);
+ if (parenthesesOpenPos < whitespacePos) {
+ if (pos !== whitespacePos + 1) {
+ token.nodes = [
+ {
+ type: "word",
+ sourceIndex: pos,
+ value: value.slice(pos, whitespacePos + 1)
+ }
+ ];
+ } else {
+ token.nodes = [];
+ }
+ if (token.unclosed && whitespacePos + 1 !== next) {
+ token.after = "";
+ token.nodes.push({
+ type: "space",
+ sourceIndex: whitespacePos + 1,
+ value: value.slice(whitespacePos + 1, next)
+ });
+ } else {
+ token.after = value.slice(whitespacePos + 1, next);
+ }
+ } else {
+ token.after = "";
+ token.nodes = [];
+ }
+ pos = next + 1;
+ code = value.charCodeAt(pos);
+ tokens.push(token);
+ } else {
+ balanced += 1;
+ token.after = "";
+ tokens.push(token);
+ stack.push(token);
+ tokens = token.nodes = [];
+ parent = token;
+ }
+ name = "";
+
+ // Close parentheses
+ } else if (closeParentheses === code && balanced) {
+ pos += 1;
+ code = value.charCodeAt(pos);
+
+ parent.after = after;
+ after = "";
+ balanced -= 1;
+ stack.pop();
+ parent = stack[balanced];
+ tokens = parent.nodes;
+
+ // Words
+ } else {
+ next = pos;
+ do {
+ if (code === backslash) {
+ next += 1;
+ }
+ next += 1;
+ code = value.charCodeAt(next);
+ } while (
+ next < max &&
+ !(
+ code <= 32 ||
+ code === singleQuote ||
+ code === doubleQuote ||
+ code === comma ||
+ code === colon ||
+ code === slash ||
+ code === openParentheses ||
+ (code === star &&
+ parent &&
+ parent.type === "function" &&
+ parent.value === "calc") ||
+ (code === slash &&
+ parent.type === "function" &&
+ parent.value === "calc") ||
+ (code === closeParentheses && balanced)
+ )
+ );
+ token = value.slice(pos, next);
+
+ if (openParentheses === code) {
+ name = token;
+ } else if (
+ (uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) &&
+ plus === token.charCodeAt(1) &&
+ isUnicodeRange.test(token.slice(2))
+ ) {
+ tokens.push({
+ type: "unicode-range",
+ sourceIndex: pos,
+ value: token
+ });
+ } else {
+ tokens.push({
+ type: "word",
+ sourceIndex: pos,
+ value: token
+ });
+ }
+
+ pos = next;
+ }
+ }
+
+ for (pos = stack.length - 1; pos; pos -= 1) {
+ stack[pos].unclosed = true;
+ }
+
+ return stack[0].nodes;
+};
diff --git a/node_modules/postcss-value-parser/lib/stringify.js b/node_modules/postcss-value-parser/lib/stringify.js
new file mode 100644
index 0000000..5f2c845
--- /dev/null
+++ b/node_modules/postcss-value-parser/lib/stringify.js
@@ -0,0 +1,48 @@
+function stringifyNode(node, custom) {
+ var type = node.type;
+ var value = node.value;
+ var buf;
+ var customResult;
+
+ if (custom && (customResult = custom(node)) !== undefined) {
+ return customResult;
+ } else if (type === "word" || type === "space") {
+ return value;
+ } else if (type === "string") {
+ buf = node.quote || "";
+ return buf + value + (node.unclosed ? "" : buf);
+ } else if (type === "comment") {
+ return "/*" + value + (node.unclosed ? "" : "*/");
+ } else if (type === "div") {
+ return (node.before || "") + value + (node.after || "");
+ } else if (Array.isArray(node.nodes)) {
+ buf = stringify(node.nodes);
+ if (type !== "function") {
+ return buf;
+ }
+ return (
+ value +
+ "(" +
+ (node.before || "") +
+ buf +
+ (node.after || "") +
+ (node.unclosed ? "" : ")")
+ );
+ }
+ return value;
+}
+
+function stringify(nodes, custom) {
+ var result, i;
+
+ if (Array.isArray(nodes)) {
+ result = "";
+ for (i = nodes.length - 1; ~i; i -= 1) {
+ result = stringifyNode(nodes[i], custom) + result;
+ }
+ return result;
+ }
+ return stringifyNode(nodes, custom);
+}
+
+module.exports = stringify;
diff --git a/node_modules/postcss-value-parser/lib/unit.js b/node_modules/postcss-value-parser/lib/unit.js
new file mode 100644
index 0000000..c349661
--- /dev/null
+++ b/node_modules/postcss-value-parser/lib/unit.js
@@ -0,0 +1,120 @@
+var minus = "-".charCodeAt(0);
+var plus = "+".charCodeAt(0);
+var dot = ".".charCodeAt(0);
+var exp = "e".charCodeAt(0);
+var EXP = "E".charCodeAt(0);
+
+// Check if three code points would start a number
+// https://www.w3.org/TR/css-syntax-3/#starts-with-a-number
+function likeNumber(value) {
+ var code = value.charCodeAt(0);
+ var nextCode;
+
+ if (code === plus || code === minus) {
+ nextCode = value.charCodeAt(1);
+
+ if (nextCode >= 48 && nextCode <= 57) {
+ return true;
+ }
+
+ var nextNextCode = value.charCodeAt(2);
+
+ if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) {
+ return true;
+ }
+
+ return false;
+ }
+
+ if (code === dot) {
+ nextCode = value.charCodeAt(1);
+
+ if (nextCode >= 48 && nextCode <= 57) {
+ return true;
+ }
+
+ return false;
+ }
+
+ if (code >= 48 && code <= 57) {
+ return true;
+ }
+
+ return false;
+}
+
+// Consume a number
+// https://www.w3.org/TR/css-syntax-3/#consume-number
+module.exports = function(value) {
+ var pos = 0;
+ var length = value.length;
+ var code;
+ var nextCode;
+ var nextNextCode;
+
+ if (length === 0 || !likeNumber(value)) {
+ return false;
+ }
+
+ code = value.charCodeAt(pos);
+
+ if (code === plus || code === minus) {
+ pos++;
+ }
+
+ while (pos < length) {
+ code = value.charCodeAt(pos);
+
+ if (code < 48 || code > 57) {
+ break;
+ }
+
+ pos += 1;
+ }
+
+ code = value.charCodeAt(pos);
+ nextCode = value.charCodeAt(pos + 1);
+
+ if (code === dot && nextCode >= 48 && nextCode <= 57) {
+ pos += 2;
+
+ while (pos < length) {
+ code = value.charCodeAt(pos);
+
+ if (code < 48 || code > 57) {
+ break;
+ }
+
+ pos += 1;
+ }
+ }
+
+ code = value.charCodeAt(pos);
+ nextCode = value.charCodeAt(pos + 1);
+ nextNextCode = value.charCodeAt(pos + 2);
+
+ if (
+ (code === exp || code === EXP) &&
+ ((nextCode >= 48 && nextCode <= 57) ||
+ ((nextCode === plus || nextCode === minus) &&
+ nextNextCode >= 48 &&
+ nextNextCode <= 57))
+ ) {
+ pos += nextCode === plus || nextCode === minus ? 3 : 2;
+
+ while (pos < length) {
+ code = value.charCodeAt(pos);
+
+ if (code < 48 || code > 57) {
+ break;
+ }
+
+ pos += 1;
+ }
+ }
+
+ return {
+ number: value.slice(0, pos),
+ unit: value.slice(pos)
+ };
+};
diff --git a/node_modules/postcss-value-parser/lib/walk.js b/node_modules/postcss-value-parser/lib/walk.js
new file mode 100644
index 0000000..7666c5b
--- /dev/null
+++ b/node_modules/postcss-value-parser/lib/walk.js
@@ -0,0 +1,22 @@
+module.exports = function walk(nodes, cb, bubble) {
+ var i, max, node, result;
+
+ for (i = 0, max = nodes.length; i < max; i += 1) {
+ node = nodes[i];
+ if (!bubble) {
+ result = cb(node, i, nodes);
+ }
+
+ if (
+ result !== false &&
+ node.type === "function" &&
+ Array.isArray(node.nodes)
+ ) {
+ walk(node.nodes, cb, bubble);
+ }
+
+ if (bubble) {
+ cb(node, i, nodes);
+ }
+ }
+};