@kimdw-rtk/ui 0.0.20 → 0.0.21

package/dist/node_modules/.pnpm/media-query-parser@2.0.2/node_modules/media-query-parser/dist/media-query-parser.esm.js

@@ -0,0 +1,1378 @@
+/*! @license MediaQueryParser - MIT License - Tom Golden (github@tbjgolden.com) */
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+var weirdNewlines = /(\u000D|\u000C|\u000D\u000A)/g;
+var nullOrSurrogates = /[\u0000\uD800-\uDFFF]/g;
+var commentRegex = /(\/\*)[\s\S]*?(\*\/)/g;
+var lexicalAnalysis = function lexicalAnalysis(str, index) {
+  if (index === void 0) {
+    index = 0;
+  }
+
+  str = str.replace(weirdNewlines, '\n').replace(nullOrSurrogates, "\uFFFD");
+  str = str.replace(commentRegex, '');
+  var tokens = [];
+
+  for (; index < str.length; index += 1) {
+    var code = str.charCodeAt(index);
+
+    if (code === 0x0009 || code === 0x0020 || code === 0x000a) {
+      var code_1 = str.charCodeAt(++index);
+
+      while (code_1 === 0x0009 || code_1 === 0x0020 || code_1 === 0x000a) {
+        code_1 = str.charCodeAt(++index);
+      }
+
+      index -= 1;
+      tokens.push({
+        type: '<whitespace-token>'
+      });
+    } else if (code === 0x0022) {
+      var result = consumeString(str, index);
+
+      if (result === null) {
+        return null;
+      }
+
+      var _a = __read(result, 2),
+          lastIndex = _a[0],
+          value = _a[1];
+
+      tokens.push({
+        type: '<string-token>',
+        value: value
+      });
+      index = lastIndex;
+    } else if (code === 0x0023) {
+      if (index + 1 < str.length) {
+        var nextCode = str.charCodeAt(index + 1);
+
+        if (nextCode === 0x005f || nextCode >= 0x0041 && nextCode <= 0x005a || nextCode >= 0x0061 && nextCode <= 0x007a || nextCode >= 0x0080 || nextCode >= 0x0030 && nextCode <= 0x0039 || nextCode === 0x005c && index + 2 < str.length && str.charCodeAt(index + 2) !== 0x000a) {
+          var flag = wouldStartIdentifier(str, index + 1) ? 'id' : 'unrestricted';
+          var result = consumeIdentUnsafe(str, index + 1);
+
+          if (result !== null) {
+            var _b = __read(result, 2),
+                lastIndex = _b[0],
+                value = _b[1];
+
+            tokens.push({
+              type: '<hash-token>',
+              value: value.toLowerCase(),
+              flag: flag
+            });
+            index = lastIndex;
+            continue;
+          }
+        }
+      }
+
+      tokens.push({
+        type: '<delim-token>',
+        value: code
+      });
+    } else if (code === 0x0027) {
+      var result = consumeString(str, index);
+
+      if (result === null) {
+        return null;
+      }
+
+      var _c = __read(result, 2),
+          lastIndex = _c[0],
+          value = _c[1];
+
+      tokens.push({
+        type: '<string-token>',
+        value: value
+      });
+      index = lastIndex;
+    } else if (code === 0x0028) {
+      tokens.push({
+        type: '<(-token>'
+      });
+    } else if (code === 0x0029) {
+      tokens.push({
+        type: '<)-token>'
+      });
+    } else if (code === 0x002b) {
+      var plusNumeric = consumeNumeric(str, index);
+
+      if (plusNumeric === null) {
+        tokens.push({
+          type: '<delim-token>',
+          value: code
+        });
+      } else {
+        var _d = __read(plusNumeric, 2),
+            lastIndex = _d[0],
+            tokenTuple = _d[1];
+
+        if (tokenTuple[0] === '<dimension-token>') {
+          tokens.push({
+            type: '<dimension-token>',
+            value: tokenTuple[1],
+            unit: tokenTuple[2].toLowerCase(),
+            flag: 'number'
+          });
+        } else if (tokenTuple[0] === '<number-token>') {
+          tokens.push({
+            type: tokenTuple[0],
+            value: tokenTuple[1],
+            flag: tokenTuple[2]
+          });
+        } else {
+          tokens.push({
+            type: tokenTuple[0],
+            value: tokenTuple[1],
+            flag: 'number'
+          });
+        }
+
+        index = lastIndex;
+      }
+    } else if (code === 0x002c) {
+      tokens.push({
+        type: '<comma-token>'
+      });
+    } else if (code === 0x002d) {
+      var minusNumeric = consumeNumeric(str, index);
+
+      if (minusNumeric !== null) {
+        var _e = __read(minusNumeric, 2),
+            lastIndex = _e[0],
+            tokenTuple = _e[1];
+
+        if (tokenTuple[0] === '<dimension-token>') {
+          tokens.push({
+            type: '<dimension-token>',
+            value: tokenTuple[1],
+            unit: tokenTuple[2].toLowerCase(),
+            flag: 'number'
+          });
+        } else if (tokenTuple[0] === '<number-token>') {
+          tokens.push({
+            type: tokenTuple[0],
+            value: tokenTuple[1],
+            flag: tokenTuple[2]
+          });
+        } else {
+          tokens.push({
+            type: tokenTuple[0],
+            value: tokenTuple[1],
+            flag: 'number'
+          });
+        }
+
+        index = lastIndex;
+        continue;
+      }
+
+      if (index + 2 < str.length) {
+        var nextCode = str.charCodeAt(index + 1);
+        var nextNextCode = str.charCodeAt(index + 2);
+
+        if (nextCode === 0x002d && nextNextCode === 0x003e) {
+          tokens.push({
+            type: '<CDC-token>'
+          });
+          index += 2;
+          continue;
+        }
+      }
+
+      var result = consumeIdentLike(str, index);
+
+      if (result !== null) {
+        var _f = __read(result, 3),
+            lastIndex = _f[0],
+            value = _f[1],
+            type = _f[2];
+
+        tokens.push({
+          type: type,
+          value: value
+        });
+        index = lastIndex;
+        continue;
+      }
+
+      tokens.push({
+        type: '<delim-token>',
+        value: code
+      });
+    } else if (code === 0x002e) {
+      var minusNumeric = consumeNumeric(str, index);
+
+      if (minusNumeric === null) {
+        tokens.push({
+          type: '<delim-token>',
+          value: code
+        });
+      } else {
+        var _g = __read(minusNumeric, 2),
+            lastIndex = _g[0],
+            tokenTuple = _g[1];
+
+        if (tokenTuple[0] === '<dimension-token>') {
+          tokens.push({
+            type: '<dimension-token>',
+            value: tokenTuple[1],
+            unit: tokenTuple[2].toLowerCase(),
+            flag: 'number'
+          });
+        } else if (tokenTuple[0] === '<number-token>') {
+          tokens.push({
+            type: tokenTuple[0],
+            value: tokenTuple[1],
+            flag: tokenTuple[2]
+          });
+        } else {
+          tokens.push({
+            type: tokenTuple[0],
+            value: tokenTuple[1],
+            flag: 'number'
+          });
+        }
+
+        index = lastIndex;
+        continue;
+      }
+    } else if (code === 0x003a) {
+      tokens.push({
+        type: '<colon-token>'
+      });
+    } else if (code === 0x003b) {
+      tokens.push({
+        type: '<semicolon-token>'
+      });
+    } else if (code === 0x003c) {
+      if (index + 3 < str.length) {
+        var nextCode = str.charCodeAt(index + 1);
+        var nextNextCode = str.charCodeAt(index + 2);
+        var nextNextNextCode = str.charCodeAt(index + 3);
+
+        if (nextCode === 0x0021 && nextNextCode === 0x002d && nextNextNextCode === 0x002d) {
+          tokens.push({
+            type: '<CDO-token>'
+          });
+          index += 3;
+          continue;
+        }
+      }
+
+      tokens.push({
+        type: '<delim-token>',
+        value: code
+      });
+    } else if (code === 0x0040) {
+      var result = consumeIdent(str, index + 1);
+
+      if (result !== null) {
+        var _h = __read(result, 2),
+            lastIndex = _h[0],
+            value = _h[1];
+
+        tokens.push({
+          type: '<at-keyword-token>',
+          value: value.toLowerCase()
+        });
+        index = lastIndex;
+        continue;
+      }
+
+      tokens.push({
+        type: '<delim-token>',
+        value: code
+      });
+    } else if (code === 0x005b) {
+      tokens.push({
+        type: '<[-token>'
+      });
+    } else if (code === 0x005c) {
+      var result = consumeEscape(str, index);
+
+      if (result === null) {
+        return null;
+      }
+
+      var _j = __read(result, 2),
+          lastIndex = _j[0],
+          value = _j[1];
+
+      str = str.slice(0, index) + value + str.slice(lastIndex + 1);
+      index -= 1;
+    } else if (code === 0x005d) {
+      tokens.push({
+        type: '<]-token>'
+      });
+    } else if (code === 0x007b) {
+      tokens.push({
+        type: '<{-token>'
+      });
+    } else if (code === 0x007d) {
+      tokens.push({
+        type: '<}-token>'
+      });
+    } else if (code >= 0x0030 && code <= 0x0039) {
+      var result = consumeNumeric(str, index);
+
+      var _k = __read(result, 2),
+          lastIndex = _k[0],
+          tokenTuple = _k[1];
+
+      if (tokenTuple[0] === '<dimension-token>') {
+        tokens.push({
+          type: '<dimension-token>',
+          value: tokenTuple[1],
+          unit: tokenTuple[2].toLowerCase(),
+          flag: 'number'
+        });
+      } else if (tokenTuple[0] === '<number-token>') {
+        tokens.push({
+          type: tokenTuple[0],
+          value: tokenTuple[1],
+          flag: tokenTuple[2]
+        });
+      } else {
+        tokens.push({
+          type: tokenTuple[0],
+          value: tokenTuple[1],
+          flag: 'number'
+        });
+      }
+
+      index = lastIndex;
+    } else if (code === 0x005f || code >= 0x0041 && code <= 0x005a || code >= 0x0061 && code <= 0x007a || code >= 0x0080) {
+      var result = consumeIdentLike(str, index);
+
+      if (result === null) {
+        return null;
+      }
+
+      var _l = __read(result, 3),
+          lastIndex = _l[0],
+          value = _l[1],
+          type = _l[2];
+
+      tokens.push({
+        type: type,
+        value: value
+      });
+      index = lastIndex;
+    } else {
+      tokens.push({
+        type: '<delim-token>',
+        value: code
+      });
+    }
+  }
+
+  tokens.push({
+    type: '<EOF-token>'
+  });
+  return tokens;
+};
+var consumeString = function consumeString(str, index) {
+  if (str.length <= index + 1) return null;
+  var firstCode = str.charCodeAt(index);
+  var charCodes = [];
+
+  for (var i = index + 1; i < str.length; i += 1) {
+    var code = str.charCodeAt(i);
+
+    if (code === firstCode) {
+      return [i, String.fromCharCode.apply(null, charCodes)];
+    } else if (code === 0x005c) {
+      var result = consumeEscape(str, i);
+      if (result === null) return null;
+
+      var _a = __read(result, 2),
+          lastIndex = _a[0],
+          charCode = _a[1];
+
+      charCodes.push(charCode);
+      i = lastIndex;
+    } else if (code === 0x000a) {
+      return null;
+    } else {
+      charCodes.push(code);
+    }
+  }
+
+  return null;
+};
+var wouldStartIdentifier = function wouldStartIdentifier(str, index) {
+  if (str.length <= index) return false;
+  var code = str.charCodeAt(index);
+
+  if (code === 0x002d) {
+    if (str.length <= index + 1) return false;
+    var nextCode = str.charCodeAt(index + 1);
+
+    if (nextCode === 0x002d || nextCode === 0x005f || nextCode >= 0x0041 && nextCode <= 0x005a || nextCode >= 0x0061 && nextCode <= 0x007a || nextCode >= 0x0080) {
+      return true;
+    } else if (nextCode === 0x005c) {
+      if (str.length <= index + 2) return false;
+      var nextNextCode = str.charCodeAt(index + 2);
+      return nextNextCode !== 0x000a;
+    } else {
+      return false;
+    }
+  } else if (code === 0x005f || code >= 0x0041 && code <= 0x005a || code >= 0x0061 && code <= 0x007a || code >= 0x0080) {
+    return true;
+  } else if (code === 0x005c) {
+    if (str.length <= index + 1) return false;
+    var nextCode = str.charCodeAt(index + 1);
+    return nextCode !== 0x000a;
+  } else {
+    return false;
+  }
+};
+var consumeEscape = function consumeEscape(str, index) {
+  if (str.length <= index + 1) return null;
+  if (str.charCodeAt(index) !== 0x005c) return null;
+  var code = str.charCodeAt(index + 1);
+
+  if (code === 0x000a) {
+    return null;
+  } else if (code >= 0x0030 && code <= 0x0039 || code >= 0x0041 && code <= 0x0046 || code >= 0x0061 && code <= 0x0066) {
+    var hexCharCodes = [code];
+    var min = Math.min(index + 7, str.length);
+    var i = index + 2;
+
+    for (; i < min; i += 1) {
+      var code_2 = str.charCodeAt(i);
+
+      if (code_2 >= 0x0030 && code_2 <= 0x0039 || code_2 >= 0x0041 && code_2 <= 0x0046 || code_2 >= 0x0061 && code_2 <= 0x0066) {
+        hexCharCodes.push(code_2);
+      } else {
+        break;
+      }
+    }
+
+    if (i < str.length) {
+      var code_3 = str.charCodeAt(i);
+
+      if (code_3 === 0x0009 || code_3 === 0x0020 || code_3 === 0x000a) {
+        i += 1;
+      }
+    }
+
+    return [i - 1, parseInt(String.fromCharCode.apply(null, hexCharCodes), 16)];
+  } else {
+    return [index + 1, code];
+  }
+};
+var consumeNumeric = function consumeNumeric(str, index) {
+  var numberResult = consumeNumber(str, index);
+  if (numberResult === null) return null;
+
+  var _a = __read(numberResult, 3),
+      numberEndIndex = _a[0],
+      numberValue = _a[1],
+      numberFlag = _a[2];
+
+  var identResult = consumeIdent(str, numberEndIndex + 1);
+
+  if (identResult !== null) {
+    var _b = __read(identResult, 2),
+        identEndIndex = _b[0],
+        identValue = _b[1];
+
+    return [identEndIndex, ['<dimension-token>', numberValue, identValue]];
+  }
+
+  if (numberEndIndex + 1 < str.length && str.charCodeAt(numberEndIndex + 1) === 0x0025) {
+    return [numberEndIndex + 1, ['<percentage-token>', numberValue]];
+  }
+
+  return [numberEndIndex, ['<number-token>', numberValue, numberFlag]];
+};
+var consumeNumber = function consumeNumber(str, index) {
+  if (str.length <= index) return null;
+  var flag = 'integer';
+  var numberChars = [];
+  var firstCode = str.charCodeAt(index);
+
+  if (firstCode === 0x002b || firstCode === 0x002d) {
+    index += 1;
+    if (firstCode === 0x002d) numberChars.push(0x002d);
+  }
+
+  while (index < str.length) {
+    var code = str.charCodeAt(index);
+
+    if (code >= 0x0030 && code <= 0x0039) {
+      numberChars.push(code);
+      index += 1;
+    } else {
+      break;
+    }
+  }
+
+  if (index + 1 < str.length) {
+    var nextCode = str.charCodeAt(index);
+    var nextNextCode = str.charCodeAt(index + 1);
+
+    if (nextCode === 0x002e && nextNextCode >= 0x0030 && nextNextCode <= 0x0039) {
+      numberChars.push(nextCode, nextNextCode);
+      flag = 'number';
+      index += 2;
+
+      while (index < str.length) {
+        var code = str.charCodeAt(index);
+
+        if (code >= 0x0030 && code <= 0x0039) {
+          numberChars.push(code);
+          index += 1;
+        } else {
+          break;
+        }
+      }
+    }
+  }
+
+  if (index + 1 < str.length) {
+    var nextCode = str.charCodeAt(index);
+    var nextNextCode = str.charCodeAt(index + 1);
+    var nextNextNextCode = str.charCodeAt(index + 2);
+
+    if (nextCode === 0x0045 || nextCode === 0x0065) {
+      var nextNextIsDigit = nextNextCode >= 0x0030 && nextNextCode <= 0x0039;
+
+      if (nextNextIsDigit || (nextNextCode === 0x002b || nextNextCode === 0x002d) && nextNextNextCode >= 0x0030 && nextNextNextCode <= 0x0039) {
+        flag = 'number';
+
+        if (nextNextIsDigit) {
+          numberChars.push(0x0045, nextNextCode);
+          index += 2;
+        } else if (nextNextCode === 0x002d) {
+          numberChars.push(0x0045, 0x002d, nextNextNextCode);
+          index += 3;
+        } else {
+          numberChars.push(0x0045, nextNextNextCode);
+          index += 3;
+        }
+
+        while (index < str.length) {
+          var code = str.charCodeAt(index);
+
+          if (code >= 0x0030 && code <= 0x0039) {
+            numberChars.push(code);
+            index += 1;
+          } else {
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  var numberString = String.fromCharCode.apply(null, numberChars);
+  var value = flag === 'number' ? parseFloat(numberString) : parseInt(numberString);
+  if (value === -0) value = 0;
+  return Number.isNaN(value) ? null : [index - 1, value, flag];
+};
+var consumeIdentUnsafe = function consumeIdentUnsafe(str, index) {
+  if (str.length <= index) {
+    return null;
+  }
+
+  var identChars = [];
+
+  for (var code = str.charCodeAt(index); index < str.length; code = str.charCodeAt(++index)) {
+    if (code === 0x002d || code === 0x005f || code >= 0x0041 && code <= 0x005a || code >= 0x0061 && code <= 0x007a || code >= 0x0080 || code >= 0x0030 && code <= 0x0039) {
+      identChars.push(code);
+      continue;
+    } else {
+      var result = consumeEscape(str, index);
+
+      if (result !== null) {
+        var _a = __read(result, 2),
+            lastIndex = _a[0],
+            code_4 = _a[1];
+
+        identChars.push(code_4);
+        index = lastIndex;
+        continue;
+      }
+    }
+
+    break;
+  }
+
+  return index === 0 ? null : [index - 1, String.fromCharCode.apply(null, identChars)];
+};
+var consumeIdent = function consumeIdent(str, index) {
+  if (str.length <= index || !wouldStartIdentifier(str, index)) {
+    return null;
+  }
+
+  var identChars = [];
+
+  for (var code = str.charCodeAt(index); index < str.length; code = str.charCodeAt(++index)) {
+    if (code === 0x002d || code === 0x005f || code >= 0x0041 && code <= 0x005a || code >= 0x0061 && code <= 0x007a || code >= 0x0080 || code >= 0x0030 && code <= 0x0039) {
+      identChars.push(code);
+      continue;
+    } else {
+      var result = consumeEscape(str, index);
+
+      if (result !== null) {
+        var _a = __read(result, 2),
+            lastIndex = _a[0],
+            code_5 = _a[1];
+
+        identChars.push(code_5);
+        index = lastIndex;
+        continue;
+      }
+    }
+
+    break;
+  }
+
+  return [index - 1, String.fromCharCode.apply(null, identChars)];
+};
+var consumeUrl = function consumeUrl(str, index) {
+  var code = str.charCodeAt(index);
+
+  while (code === 0x0009 || code === 0x0020 || code === 0x000a) {
+    code = str.charCodeAt(++index);
+  }
+
+  var urlChars = [];
+  var hasFinishedWord = false;
+
+  while (index < str.length) {
+    if (code === 0x0029) {
+      return [index, String.fromCharCode.apply(null, urlChars)];
+    } else if (code === 0x0022 || code === 0x0027 || code === 0x0028) {
+      return null;
+    } else if (code === 0x0009 || code === 0x0020 || code === 0x000a) {
+      if (!hasFinishedWord && urlChars.length !== 0) hasFinishedWord = true;
+    } else if (code === 0x005c) {
+      var result = consumeEscape(str, index);
+      if (result === null || hasFinishedWord) return null;
+
+      var _a = __read(result, 2),
+          lastIndex = _a[0],
+          value = _a[1];
+
+      urlChars.push(value);
+      index = lastIndex;
+    } else {
+      if (hasFinishedWord) return null;
+      urlChars.push(code);
+    }
+
+    code = str.charCodeAt(++index);
+  }
+
+  return null;
+};
+var consumeIdentLike = function consumeIdentLike(str, index) {
+  var result = consumeIdent(str, index);
+  if (result === null) return null;
+
+  var _a = __read(result, 2),
+      lastIndex = _a[0],
+      value = _a[1];
+
+  if (value.toLowerCase() === 'url') {
+    if (str.length > lastIndex + 1) {
+      var nextCode = str.charCodeAt(lastIndex + 1);
+
+      if (nextCode === 0x0028) {
+        for (var offset = 2; lastIndex + offset < str.length; offset += 1) {
+          var nextNextCode = str.charCodeAt(lastIndex + offset);
+
+          if (nextNextCode === 0x0022 || nextNextCode === 0x0027) {
+            return [lastIndex + 1, value.toLowerCase(), '<function-token>'];
+          } else if (nextNextCode !== 0x0009 && nextNextCode !== 0x0020 && nextNextCode !== 0x000a) {
+            var result_1 = consumeUrl(str, lastIndex + offset);
+            if (result_1 === null) return null;
+
+            var _b = __read(result_1, 2),
+                lastUrlIndex = _b[0],
+                value_1 = _b[1];
+
+            return [lastUrlIndex, value_1, '<url-token>'];
+          }
+        }
+
+        return [lastIndex + 1, value.toLowerCase(), '<function-token>'];
+      }
+    }
+  } else if (str.length > lastIndex + 1) {
+    var nextCode = str.charCodeAt(lastIndex + 1);
+
+    if (nextCode === 0x0028) {
+      return [lastIndex + 1, value.toLowerCase(), '<function-token>'];
+    }
+  }
+
+  return [lastIndex, value.toLowerCase(), '<ident-token>'];
+};
+
+var simplifyAST = function simplifyAST(ast) {
+  for (var i = ast.length - 1; i >= 0; i--) {
+    ast[i] = simplifyMediaQuery(ast[i]);
+  }
+
+  return ast;
+};
+
+var simplifyMediaQuery = function simplifyMediaQuery(mediaQuery) {
+  if (mediaQuery.mediaCondition === null) return mediaQuery;
+  var mediaCondition = simplifyMediaCondition(mediaQuery.mediaCondition);
+
+  if (mediaCondition.operator === null && mediaCondition.children.length === 1 && 'children' in mediaCondition.children[0]) {
+    mediaCondition = mediaCondition.children[0];
+  }
+
+  return {
+    mediaPrefix: mediaQuery.mediaPrefix,
+    mediaType: mediaQuery.mediaType,
+    mediaCondition: mediaCondition
+  };
+};
+
+var simplifyMediaCondition = function simplifyMediaCondition(mediaCondition) {
+  for (var i = mediaCondition.children.length - 1; i >= 0; i--) {
+    var unsimplifiedChild = mediaCondition.children[i];
+
+    if (!('context' in unsimplifiedChild)) {
+      var child = simplifyMediaCondition(unsimplifiedChild);
+
+      if (child.operator === null && child.children.length === 1) {
+        mediaCondition.children[i] = child.children[0];
+      } else if (child.operator === mediaCondition.operator && (child.operator === 'and' || child.operator === 'or')) {
+        var spliceArgs = [i, 1];
+
+        for (var i_1 = 0; i_1 < child.children.length; i_1++) {
+          spliceArgs.push(child.children[i_1]);
+        }
+
+        mediaCondition.children.splice.apply(mediaCondition.children, spliceArgs);
+      }
+    }
+  }
+
+  return mediaCondition;
+};
+
+var createError = function createError(message, err) {
+  if (err instanceof Error) {
+    return new Error("".concat(err.message.trim(), "\n").concat(message.trim()));
+  } else {
+    return new Error(message.trim());
+  }
+};
+
+var toAST = function toAST(str) {
+  return simplifyAST(toUnflattenedAST(str));
+};
+var toUnflattenedAST = function toUnflattenedAST(str) {
+  var tokenList = lexicalAnalysis(str.trim());
+
+  if (tokenList === null) {
+    throw createError('Failed tokenizing');
+  }
+
+  var startIndex = 0;
+  var endIndex = tokenList.length - 1;
+
+  if (tokenList[0].type === '<at-keyword-token>' && tokenList[0].value === 'media') {
+    if (tokenList[1].type !== '<whitespace-token>') {
+      throw createError('Expected whitespace after media');
+    }
+
+    startIndex = 2;
+
+    for (var i = 2; i < tokenList.length - 1; i++) {
+      var token = tokenList[i];
+
+      if (token.type === '<{-token>') {
+        endIndex = i;
+        break;
+      } else if (token.type === '<semicolon-token>') {
+        throw createError("Expected '{' in media query but found ';'");
+      }
+    }
+  }
+
+  tokenList = tokenList.slice(startIndex, endIndex);
+  return syntacticAnalysis(tokenList);
+};
+var removeWhitespace = function removeWhitespace(tokenList) {
+  var newTokenList = [];
+  var before = false;
+
+  for (var i = 0; i < tokenList.length; i++) {
+    if (tokenList[i].type === '<whitespace-token>') {
+      before = true;
+
+      if (newTokenList.length > 0) {
+        newTokenList[newTokenList.length - 1].wsAfter = true;
+      }
+    } else {
+      newTokenList.push(__assign(__assign({}, tokenList[i]), {
+        wsBefore: before,
+        wsAfter: false
+      }));
+      before = false;
+    }
+  }
+
+  return newTokenList;
+};
+var syntacticAnalysis = function syntacticAnalysis(tokenList) {
+  var e_1, _a;
+
+  var mediaQueryList = [[]];
+
+  for (var i = 0; i < tokenList.length; i++) {
+    var token = tokenList[i];
+
+    if (token.type === '<comma-token>') {
+      mediaQueryList.push([]);
+    } else {
+      mediaQueryList[mediaQueryList.length - 1].push(token);
+    }
+  }
+
+  var mediaQueries = mediaQueryList.map(removeWhitespace);
+
+  if (mediaQueries.length === 1 && mediaQueries[0].length === 0) {
+    return [{
+      mediaCondition: null,
+      mediaPrefix: null,
+      mediaType: 'all'
+    }];
+  } else {
+    var mediaQueryTokens = mediaQueries.map(function (mediaQueryTokens) {
+      if (mediaQueryTokens.length === 0) {
+        return null;
+      } else {
+        return tokenizeMediaQuery(mediaQueryTokens);
+      }
+    });
+    var nonNullMediaQueryTokens = [];
+
+    try {
+      for (var mediaQueryTokens_1 = __values(mediaQueryTokens), mediaQueryTokens_1_1 = mediaQueryTokens_1.next(); !mediaQueryTokens_1_1.done; mediaQueryTokens_1_1 = mediaQueryTokens_1.next()) {
+        var mediaQueryToken = mediaQueryTokens_1_1.value;
+
+        if (mediaQueryToken !== null) {
+          nonNullMediaQueryTokens.push(mediaQueryToken);
+        }
+      }
+    } catch (e_1_1) {
+      e_1 = {
+        error: e_1_1
+      };
+    } finally {
+      try {
+        if (mediaQueryTokens_1_1 && !mediaQueryTokens_1_1.done && (_a = mediaQueryTokens_1["return"])) _a.call(mediaQueryTokens_1);
+      } finally {
+        if (e_1) throw e_1.error;
+      }
+    }
+
+    if (nonNullMediaQueryTokens.length === 0) {
+      throw createError('No valid media queries');
+    }
+
+    return nonNullMediaQueryTokens;
+  }
+};
+var tokenizeMediaQuery = function tokenizeMediaQuery(tokens) {
+  var firstToken = tokens[0];
+
+  if (firstToken.type === '<(-token>') {
+    try {
+      return {
+        mediaPrefix: null,
+        mediaType: 'all',
+        mediaCondition: tokenizeMediaCondition(tokens, true)
+      };
+    } catch (err) {
+      throw createError("Expected media condition after '('", err);
+    }
+  } else if (firstToken.type === '<ident-token>') {
+    var mediaPrefix = null;
+    var mediaType = void 0;
+    var value = firstToken.value;
+
+    if (value === 'only' || value === 'not') {
+      mediaPrefix = value;
+    }
+
+    var firstIndex = mediaPrefix === null ? 0 : 1;
+
+    if (tokens.length <= firstIndex) {
+      throw createError("Expected extra token in media query");
+    }
+
+    var firstNonUnaryToken = tokens[firstIndex];
+
+    if (firstNonUnaryToken.type === '<ident-token>') {
+      var value_1 = firstNonUnaryToken.value;
+
+      if (value_1 === 'all') {
+        mediaType = 'all';
+      } else if (value_1 === 'print' || value_1 === 'screen') {
+        mediaType = value_1;
+      } else if (value_1 === 'tty' || value_1 === 'tv' || value_1 === 'projection' || value_1 === 'handheld' || value_1 === 'braille' || value_1 === 'embossed' || value_1 === 'aural' || value_1 === 'speech') {
+        mediaPrefix = mediaPrefix === 'not' ? null : 'not';
+        mediaType = 'all';
+      } else {
+        throw createError("Unknown ident '".concat(value_1, "' in media query"));
+      }
+    } else if (mediaPrefix === 'not' && firstNonUnaryToken.type === '<(-token>') {
+      var tokensWithParens = [{
+        type: '<(-token>',
+        wsBefore: false,
+        wsAfter: false
+      }];
+      tokensWithParens.push.apply(tokensWithParens, tokens);
+      tokensWithParens.push({
+        type: '<)-token>',
+        wsBefore: false,
+        wsAfter: false
+      });
+
+      try {
+        return {
+          mediaPrefix: null,
+          mediaType: 'all',
+          mediaCondition: tokenizeMediaCondition(tokensWithParens, true)
+        };
+      } catch (err) {
+        throw createError("Expected media condition after '('", err);
+      }
+    } else {
+      throw createError('Invalid media query');
+    }
+
+    if (firstIndex + 1 === tokens.length) {
+      return {
+        mediaPrefix: mediaPrefix,
+        mediaType: mediaType,
+        mediaCondition: null
+      };
+    } else if (firstIndex + 4 < tokens.length) {
+      var secondNonUnaryToken = tokens[firstIndex + 1];
+
+      if (secondNonUnaryToken.type === '<ident-token>' && secondNonUnaryToken.value === 'and') {
+        try {
+          return {
+            mediaPrefix: mediaPrefix,
+            mediaType: mediaType,
+            mediaCondition: tokenizeMediaCondition(tokens.slice(firstIndex + 2), false)
+          };
+        } catch (err) {
+          throw createError("Expected media condition after 'and'", err);
+        }
+      } else {
+        throw createError("Expected 'and' after media prefix");
+      }
+    } else {
+      throw createError('Expected media condition after media prefix');
+    }
+  } else {
+    throw createError('Expected media condition or media prefix');
+  }
+};
+var tokenizeMediaCondition = function tokenizeMediaCondition(tokens, mayContainOr, previousOperator) {
+  if (previousOperator === void 0) {
+    previousOperator = null;
+  }
+
+  if (tokens.length < 3 || tokens[0].type !== '<(-token>' || tokens[tokens.length - 1].type !== '<)-token>') {
+    throw new Error('Invalid media condition');
+  }
+
+  var endIndexOfFirstFeature = tokens.length - 1;
+  var maxDepth = 0;
+  var count = 0;
+
+  for (var i = 0; i < tokens.length; i++) {
+    var token = tokens[i];
+
+    if (token.type === '<(-token>') {
+      count += 1;
+      maxDepth = Math.max(maxDepth, count);
+    } else if (token.type === '<)-token>') {
+      count -= 1;
+    }
+
+    if (count === 0) {
+      endIndexOfFirstFeature = i;
+      break;
+    }
+  }
+
+  if (count !== 0) {
+    throw new Error('Mismatched parens\nInvalid media condition');
+  }
+
+  var child;
+  var featureTokens = tokens.slice(0, endIndexOfFirstFeature + 1);
+
+  if (maxDepth === 1) {
+    child = tokenizeMediaFeature(featureTokens);
+  } else {
+    if (featureTokens[1].type === '<ident-token>' && featureTokens[1].value === 'not') {
+      child = tokenizeMediaCondition(featureTokens.slice(2, -1), true, 'not');
+    } else {
+      child = tokenizeMediaCondition(featureTokens.slice(1, -1), true);
+    }
+  }
+
+  if (endIndexOfFirstFeature === tokens.length - 1) {
+    return {
+      operator: previousOperator,
+      children: [child]
+    };
+  } else {
+    var nextToken = tokens[endIndexOfFirstFeature + 1];
+
+    if (nextToken.type !== '<ident-token>') {
+      throw new Error('Invalid operator\nInvalid media condition');
+    } else if (previousOperator !== null && previousOperator !== nextToken.value) {
+      throw new Error("'".concat(nextToken.value, "' and '").concat(previousOperator, "' must not be at same level\nInvalid media condition"));
+    } else if (nextToken.value === 'or' && !mayContainOr) {
+      throw new Error("Cannot use 'or' at top level of a media query\nInvalid media condition");
+    } else if (nextToken.value !== 'and' && nextToken.value !== 'or') {
+      throw new Error("Invalid operator: '".concat(nextToken.value, "'\nInvalid media condition"));
+    }
+
+    var siblings = tokenizeMediaCondition(tokens.slice(endIndexOfFirstFeature + 2), mayContainOr, nextToken.value);
+    return {
+      operator: nextToken.value,
+      children: [child].concat(siblings.children)
+    };
+  }
+};
+var tokenizeMediaFeature = function tokenizeMediaFeature(rawTokens) {
+  if (rawTokens.length < 3 || rawTokens[0].type !== '<(-token>' || rawTokens[rawTokens.length - 1].type !== '<)-token>') {
+    throw new Error('Invalid media feature');
+  }
+
+  var tokens = [rawTokens[0]];
+
+  for (var i = 1; i < rawTokens.length; i++) {
+    if (i < rawTokens.length - 2) {
+      var a = rawTokens[i];
+      var b = rawTokens[i + 1];
+      var c = rawTokens[i + 2];
+
+      if (a.type === '<number-token>' && a.value > 0 && b.type === '<delim-token>' && b.value === 0x002f && c.type === '<number-token>' && c.value > 0) {
+        tokens.push({
+          type: '<ratio-token>',
+          numerator: a.value,
+          denominator: c.value,
+          wsBefore: a.wsBefore,
+          wsAfter: c.wsAfter
+        });
+        i += 2;
+        continue;
+      }
+    }
+
+    tokens.push(rawTokens[i]);
+  }
+
+  var nextToken = tokens[1];
+
+  if (nextToken.type === '<ident-token>' && tokens.length === 3) {
+    return {
+      context: 'boolean',
+      feature: nextToken.value
+    };
+  } else if (tokens.length === 5 && tokens[1].type === '<ident-token>' && tokens[2].type === '<colon-token>') {
+    var valueToken = tokens[3];
+
+    if (valueToken.type === '<number-token>' || valueToken.type === '<dimension-token>' || valueToken.type === '<ratio-token>' || valueToken.type === '<ident-token>') {
+      var feature = tokens[1].value;
+      var prefix = null;
+      var slice = feature.slice(0, 4);
+
+      if (slice === 'min-') {
+        prefix = 'min';
+        feature = feature.slice(4);
+      } else if (slice === 'max-') {
+        prefix = 'max';
+        feature = feature.slice(4);
+      }
+          var value = __rest(valueToken, ["wsBefore", "wsAfter"]);
+
+      return {
+        context: 'value',
+        prefix: prefix,
+        feature: feature,
+        value: value
+      };
+    }
+  } else if (tokens.length >= 5) {
+    try {
+      var range = tokenizeRange(tokens);
+      return {
+        context: 'range',
+        feature: range.featureName,
+        range: range
+      };
+    } catch (err) {
+      throw createError('Invalid media feature', err);
+    }
+  }
+
+  throw new Error('Invalid media feature');
+};
+var tokenizeRange = function tokenizeRange(tokens) {
+  var _a, _b, _c, _d;
+
+  if (tokens.length < 5 || tokens[0].type !== '<(-token>' || tokens[tokens.length - 1].type !== '<)-token>') {
+    throw new Error('Invalid range');
+  }
+
+  var range = {
+    leftToken: null,
+    leftOp: null,
+    featureName: '',
+    rightOp: null,
+    rightToken: null
+  };
+  var hasLeft = tokens[1].type === '<number-token>' || tokens[1].type === '<dimension-token>' || tokens[1].type === '<ratio-token>' || tokens[1].type === '<ident-token>' && tokens[1].value === 'infinite';
+
+  if (tokens[2].type === '<delim-token>') {
+    if (tokens[2].value === 0x003c) {
+      if (tokens[3].type === '<delim-token>' && tokens[3].value === 0x003d && !tokens[3].wsBefore) {
+        range[hasLeft ? 'leftOp' : 'rightOp'] = '<=';
+      } else {
+        range[hasLeft ? 'leftOp' : 'rightOp'] = '<';
+      }
+    } else if (tokens[2].value === 0x003e) {
+      if (tokens[3].type === '<delim-token>' && tokens[3].value === 0x003d && !tokens[3].wsBefore) {
+        range[hasLeft ? 'leftOp' : 'rightOp'] = '>=';
+      } else {
+        range[hasLeft ? 'leftOp' : 'rightOp'] = '>';
+      }
+    } else if (tokens[2].value === 0x003d) {
+      range[hasLeft ? 'leftOp' : 'rightOp'] = '=';
+    } else {
+      throw new Error('Invalid range');
+    }
+
+    if (hasLeft) {
+      range.leftToken = tokens[1];
+    } else if (tokens[1].type === '<ident-token>') {
+      range.featureName = tokens[1].value;
+    } else {
+      throw new Error('Invalid range');
+    }
+
+    var tokenIndexAfterFirstOp = 2 + ((_b = (_a = range[hasLeft ? 'leftOp' : 'rightOp']) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0);
+    var tokenAfterFirstOp = tokens[tokenIndexAfterFirstOp];
+
+    if (hasLeft) {
+      if (tokenAfterFirstOp.type === '<ident-token>') {
+        range.featureName = tokenAfterFirstOp.value;
+
+        if (tokens.length >= 7) {
+          var secondOpToken = tokens[tokenIndexAfterFirstOp + 1];
+          var followingToken = tokens[tokenIndexAfterFirstOp + 2];
+
+          if (secondOpToken.type === '<delim-token>') {
+            var charCode = secondOpToken.value;
+
+            if (charCode === 0x003c) {
+              if (followingToken.type === '<delim-token>' && followingToken.value === 0x003d && !followingToken.wsBefore) {
+                range.rightOp = '<=';
+              } else {
+                range.rightOp = '<';
+              }
+            } else if (charCode === 0x003e) {
+              if (followingToken.type === '<delim-token>' && followingToken.value === 0x003d && !followingToken.wsBefore) {
+                range.rightOp = '>=';
+              } else {
+                range.rightOp = '>';
+              }
+            } else {
+              throw new Error('Invalid range');
+            }
+
+            var tokenAfterSecondOp = tokens[tokenIndexAfterFirstOp + 1 + ((_d = (_c = range.rightOp) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0)];
+            range.rightToken = tokenAfterSecondOp;
+          } else {
+            throw new Error('Invalid range');
+          }
+        } else if (tokenIndexAfterFirstOp + 2 !== tokens.length) {
+          throw new Error('Invalid range');
+        }
+      } else {
+        throw new Error('Invalid range');
+      }
+    } else {
+      range.rightToken = tokenAfterFirstOp;
+    }
+
+    var validRange = null;
+    var lt = range.leftToken,
+        leftOp = range.leftOp,
+        featureName = range.featureName,
+        rightOp = range.rightOp,
+        rt = range.rightToken;
+    var leftToken = null;
+
+    if (lt !== null) {
+      if (lt.type === '<ident-token>') {
+        var type = lt.type,
+            value = lt.value;
+
+        if (value === 'infinite') {
+          leftToken = {
+            type: type,
+            value: value
+          };
+        }
+      } else if (lt.type === '<number-token>' || lt.type === '<dimension-token>' || lt.type === '<ratio-token>') {
+            var ltNoWS = __rest(lt, ["wsBefore", "wsAfter"]);
+
+        leftToken = ltNoWS;
+      }
+    }
+
+    var rightToken = null;
+
+    if (rt !== null) {
+      if (rt.type === '<ident-token>') {
+        var type = rt.type,
+            value = rt.value;
+
+        if (value === 'infinite') {
+          rightToken = {
+            type: type,
+            value: value
+          };
+        }
+      } else if (rt.type === '<number-token>' || rt.type === '<dimension-token>' || rt.type === '<ratio-token>') {
+            var rtNoWS = __rest(rt, ["wsBefore", "wsAfter"]);
+
+        rightToken = rtNoWS;
+      }
+    }
+
+    if (leftToken !== null && rightToken !== null) {
+      if ((leftOp === '<' || leftOp === '<=') && (rightOp === '<' || rightOp === '<=')) {
+        validRange = {
+          leftToken: leftToken,
+          leftOp: leftOp,
+          featureName: featureName,
+          rightOp: rightOp,
+          rightToken: rightToken
+        };
+      } else if ((leftOp === '>' || leftOp === '>=') && (rightOp === '>' || rightOp === '>=')) {
+        validRange = {
+          leftToken: leftToken,
+          leftOp: leftOp,
+          featureName: featureName,
+          rightOp: rightOp,
+          rightToken: rightToken
+        };
+      } else {
+        throw new Error('Invalid range');
+      }
+    } else if (leftToken === null && leftOp === null && rightOp !== null && rightToken !== null) {
+      validRange = {
+        leftToken: leftToken,
+        leftOp: leftOp,
+        featureName: featureName,
+        rightOp: rightOp,
+        rightToken: rightToken
+      };
+    } else if (leftToken !== null && leftOp !== null && rightOp === null && rightToken === null) {
+      validRange = {
+        leftToken: leftToken,
+        leftOp: leftOp,
+        featureName: featureName,
+        rightOp: rightOp,
+        rightToken: rightToken
+      };
+    }
+
+    return validRange;
+  } else {
+    throw new Error('Invalid range');
+  }
+};
+
+export { consumeEscape, consumeIdent, consumeIdentLike, consumeIdentUnsafe, consumeNumber, consumeNumeric, consumeString, consumeUrl, lexicalAnalysis, removeWhitespace, syntacticAnalysis, toAST, toUnflattenedAST, tokenizeMediaCondition, tokenizeMediaFeature, tokenizeMediaQuery, tokenizeRange, wouldStartIdentifier };