@navecss/core 0.1.1 → 0.3.0

package/dist/chunk-NFS2REPQ.js

@@ -0,0 +1,747 @@
+// src/directive/expand-text-diagnostics.ts
+function lineStartOffsets(text) {
+  const starts = [0];
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === "\r") {
+      i++;
+      if (text[i] === "\n") i++;
+      starts.push(i);
+      continue;
+    }
+    if (c === "\n" || c === "\f") {
+      i++;
+      starts.push(i);
+      continue;
+    }
+    i++;
+  }
+  return starts;
+}
+function lastAtOrBefore(starts, offset) {
+  let low = 0;
+  let high = starts.length - 1;
+  while (low < high) {
+    const mid = low + high + 1 >> 1;
+    if (starts[mid] <= offset) low = mid;
+    else high = mid - 1;
+  }
+  return low;
+}
+function createPositionFinder(text) {
+  const starts = lineStartOffsets(text);
+  return (offset) => {
+    const line = lastAtOrBefore(starts, offset);
+    return { line: line + 1, column: offset - starts[line] };
+  };
+}
+function reportDiagnostics(diagnostics, css, options) {
+  const onUnknown = options.onUnknown ?? "error";
+  if (onUnknown === "ignore") return [];
+  const severity = onUnknown === "warn" ? "warning" : "error";
+  const positionAt = createPositionFinder(css);
+  return diagnostics.map((diagnostic) => {
+    const position = positionAt(diagnostic.offset);
+    return {
+      ...diagnostic,
+      severity,
+      ...options.from !== void 0 && { file: options.from },
+      line: position.line,
+      column: position.column + 1
+    };
+  });
+}
+
+// src/directive/bracket-match.ts
+var OPENERS = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token", "{-token"]);
+var CLOSERS = /* @__PURE__ */ new Set([")-token", "]-token", "}-token"]);
+function isMirrorCloser(openerType, closerType) {
+  if (closerType === ")-token") return openerType === "(-token" || openerType === "function-token";
+  if (closerType === "]-token") return openerType === "[-token";
+  return openerType === "{-token";
+}
+function matchBrackets(tokens) {
+  const closerFor = new Int32Array(tokens.length).fill(-1);
+  const opens = [];
+  for (const [i, token] of tokens.entries()) {
+    const { type } = token;
+    if (OPENERS.has(type)) {
+      opens.push(i);
+      continue;
+    }
+    if (!CLOSERS.has(type)) continue;
+    const openIndex = opens.at(-1);
+    if (openIndex === void 0 || !isMirrorCloser(tokens[openIndex].type, type)) continue;
+    opens.pop();
+    closerFor[openIndex] = i;
+  }
+  return closerFor;
+}
+function matchedCloseWithin(closerFor, openIndex, limit) {
+  const closeIndex = closerFor[openIndex];
+  return closeIndex !== -1 && closeIndex < limit ? closeIndex : void 0;
+}
+
+// src/directive/block-reader.ts
+function scanItem(tokens, start, limit, closerFor) {
+  let i = start;
+  while (i < limit) {
+    const type = tokens[i].type;
+    if (OPENERS.has(type)) {
+      const closeIndex = matchedCloseWithin(closerFor, i, limit);
+      if (type === "{-token") {
+        return {
+          end: closeIndex === void 0 ? limit : closeIndex + 1,
+          consumedSemicolon: false,
+          trailingBlock: { openIndex: i, closeIndex }
+        };
+      }
+      i = closeIndex === void 0 ? limit : closeIndex + 1;
+      continue;
+    }
+    if (CLOSERS.has(type)) {
+      if (i === start) return { end: i + 1, consumedSemicolon: false };
+      i++;
+      continue;
+    }
+    if (type === "semicolon-token") return { end: i + 1, consumedSemicolon: true };
+    i++;
+  }
+  return { end: i, consumedSemicolon: false };
+}
+function scanCustomPropertyValue(tokens, start, limit, closerFor) {
+  let i = start;
+  while (i < limit) {
+    const type = tokens[i].type;
+    if (OPENERS.has(type)) {
+      const closeIndex = matchedCloseWithin(closerFor, i, limit);
+      i = closeIndex === void 0 ? limit : closeIndex + 1;
+      continue;
+    }
+    if (type === "semicolon-token") return i + 1;
+    i++;
+  }
+  return i;
+}
+function isColonSoonAfter(tokens, i, limit) {
+  let j = i;
+  while (j < limit && (tokens[j].type === "whitespace-token" || tokens[j].type === "comment")) j++;
+  return tokens[j]?.type === "colon-token";
+}
+function isCustomPropertyName(token) {
+  return token.type === "ident-token" && (token.structured?.value).startsWith("--");
+}
+function atKeywordName(token) {
+  return (token.structured?.value).toLowerCase();
+}
+function toDeclarationItem(start, end) {
+  return { kind: "declaration", start, end };
+}
+function preludeEndOffset(tokens, start, scan, preludeStart) {
+  if (scan.trailingBlock) return tokens[scan.trailingBlock.openIndex].startIndex;
+  const lastContentIndex = scan.consumedSemicolon ? scan.end - 2 : scan.end - 1;
+  return lastContentIndex >= start ? tokens[lastContentIndex].endIndex : preludeStart;
+}
+function toAtRuleItem(tokens, start, scan) {
+  const nameToken = tokens[start];
+  const preludeStart = tokens[start + 1]?.startIndex ?? nameToken.endIndex;
+  return {
+    kind: "at-rule",
+    start,
+    end: scan.end,
+    atKeyword: atKeywordName(nameToken),
+    preludeOffset: preludeStart,
+    preludeEndOffset: preludeEndOffset(tokens, start + 1, scan, preludeStart),
+    ...scan.trailingBlock && {
+      blockStart: scan.trailingBlock.openIndex + 1,
+      blockEnd: scan.trailingBlock.closeIndex ?? scan.end
+    }
+  };
+}
+function toRuleOrInvalidItem(start, scan) {
+  if (!scan.trailingBlock) return { kind: "invalid", start, end: scan.end };
+  return {
+    kind: "rule",
+    start,
+    end: scan.end,
+    blockStart: scan.trailingBlock.openIndex + 1,
+    blockEnd: scan.trailingBlock.closeIndex ?? scan.end
+  };
+}
+function readItem(tokens, start, limit, closerFor) {
+  const first = tokens[start];
+  if (first.type === "at-keyword-token") {
+    return toAtRuleItem(tokens, start, scanItem(tokens, start + 1, limit, closerFor));
+  }
+  if (first.type === "ident-token" && isColonSoonAfter(tokens, start + 1, limit)) {
+    if (isCustomPropertyName(first)) {
+      return toDeclarationItem(start, scanCustomPropertyValue(tokens, start + 1, limit, closerFor));
+    }
+    const scan = scanItem(tokens, start + 1, limit, closerFor);
+    if (!scan.trailingBlock) return toDeclarationItem(start, scan.end);
+    return toRuleOrInvalidItem(start, scan);
+  }
+  return toRuleOrInvalidItem(start, scanItem(tokens, start, limit, closerFor));
+}
+function isNaveAtKeyword(token) {
+  return token.type === "at-keyword-token" && atKeywordName(token) === "nave";
+}
+
+// src/directive/tokenizer/comment.ts
+function tryConsumeComment(s, start) {
+  if (s.peek() !== "/" || s.peek(1) !== "*") return void 0;
+  s.advance(2);
+  for (; ; ) {
+    if (s.eof()) break;
+    if (s.peek() === "*" && s.peek(1) === "/") {
+      s.advance(2);
+      break;
+    }
+    s.advance();
+  }
+  return {
+    type: "comment",
+    raw: s.input.slice(start, s.pos),
+    startIndex: start,
+    endIndex: s.pos,
+    // eslint-disable-next-line unicorn/no-null -- the corpus's format carries null (not undefined) for a comment's structured field
+    structured: null
+  };
+}
+
+// src/directive/tokenizer/scanner.ts
+function isDigit(c) {
+  return c !== void 0 && c >= "0" && c <= "9";
+}
+function isHexDigit(c) {
+  if (isDigit(c)) return true;
+  return c !== void 0 && (c >= "a" && c <= "f" || c >= "A" && c <= "F");
+}
+function isLetter(c) {
+  return c !== void 0 && (c >= "a" && c <= "z" || c >= "A" && c <= "Z");
+}
+var NON_ASCII_IDENT_RANGES = [
+  [0, 0],
+  // NUL, read back as U+FFFD by consumeLiteralCodePoint
+  [183, 183],
+  [192, 214],
+  [216, 246],
+  [248, 893],
+  [895, 8191],
+  [8204, 8205],
+  [8255, 8256],
+  [8304, 8591],
+  [11264, 12271],
+  [12289, 55295],
+  [55296, 57343],
+  // any surrogate code unit, lone or half of a pair
+  [63744, 64975],
+  [65008, 65533]
+];
+function isNonAsciiIdentCodePoint(c) {
+  if (c === void 0) return false;
+  const cp = c.codePointAt(0);
+  return NON_ASCII_IDENT_RANGES.some(([low, high]) => cp >= low && cp <= high);
+}
+function isIdentStartCodePoint(c) {
+  return c !== void 0 && (isLetter(c) || isNonAsciiIdentCodePoint(c) || c === "_");
+}
+function isIdentCodePoint(c) {
+  return c !== void 0 && (isIdentStartCodePoint(c) || isDigit(c) || c === "-");
+}
+var WHITESPACE_CHARS = /* @__PURE__ */ new Set([" ", "	", "\n", "\r", "\f"]);
+function isWhitespace(c) {
+  return c !== void 0 && WHITESPACE_CHARS.has(c);
+}
+var NON_PRINTABLE_RANGES = [
+  [0, 8],
+  [11, 11],
+  [14, 31],
+  [127, 127]
+];
+function isNonPrintable(c) {
+  if (c === void 0) return false;
+  const cp = c.codePointAt(0);
+  return NON_PRINTABLE_RANGES.some(([low, high]) => cp >= low && cp <= high);
+}
+var Scanner = class {
+  input;
+  pos = 0;
+  constructor(input) {
+    this.input = input;
+  }
+  advance(count = 1) {
+    this.pos += count;
+  }
+  eof(offset = 0) {
+    return this.pos + offset >= this.input.length;
+  }
+  peek(offset = 0) {
+    return this.input[this.pos + offset];
+  }
+};
+function isValidEscapeAt(s, offset = 0) {
+  if (s.peek(offset) !== "\\") return false;
+  const next = s.peek(offset + 1);
+  return next !== "\n" && next !== "\r" && next !== "\f";
+}
+function isIdentSequenceStartAt(s, offset = 0) {
+  const c0 = s.peek(offset);
+  if (c0 === "-") {
+    const c1 = s.peek(offset + 1);
+    if (c1 === "-" || isIdentStartCodePoint(c1)) return true;
+    return isValidEscapeAt(s, offset + 1);
+  }
+  if (isIdentStartCodePoint(c0)) return true;
+  return isValidEscapeAt(s, offset);
+}
+function isNumberStartAt(s, offset = 0) {
+  const c0 = s.peek(offset);
+  if (c0 === "+" || c0 === "-") {
+    const c1 = s.peek(offset + 1);
+    if (isDigit(c1)) return true;
+    return c1 === "." && isDigit(s.peek(offset + 2));
+  }
+  if (c0 === ".") return isDigit(s.peek(offset + 1));
+  return isDigit(c0);
+}
+function didConsumeNewline(s) {
+  if (s.peek() === "\r" && s.peek(1) === "\n") {
+    s.advance(2);
+    return true;
+  }
+  if (s.peek() === "\n" || s.peek() === "\r" || s.peek() === "\f") {
+    s.advance(1);
+    return true;
+  }
+  return false;
+}
+function consumeLiteralCodePoint(s) {
+  const cp = s.input.codePointAt(s.pos) ?? 0;
+  if (cp === 0 || cp >= 55296 && cp <= 57343) {
+    s.advance();
+    return "\uFFFD";
+  }
+  const width = cp > 65535 ? 2 : 1;
+  const text = s.input.slice(s.pos, s.pos + width);
+  s.advance(width);
+  return text;
+}
+
+// src/directive/tokenizer/escape.ts
+function consumeEscapeHexDigits(s) {
+  let hex = s.peek() ?? "";
+  s.advance();
+  for (let i = 0; i < 5 && isHexDigit(s.peek()); i++) {
+    hex += s.peek();
+    s.advance();
+  }
+  return hex;
+}
+function isMaxAllowedCodePoint(value) {
+  return value !== 0 && !(value >= 55296 && value <= 57343) && value <= 1114111;
+}
+function consumeEscapedCodePoint(s) {
+  if (s.eof()) return "\uFFFD";
+  if (!isHexDigit(s.peek())) return consumeLiteralCodePoint(s);
+  const hex = consumeEscapeHexDigits(s);
+  if (!didConsumeNewline(s) && (s.peek() === " " || s.peek() === "	")) s.advance();
+  const value = Number.parseInt(hex, 16);
+  return isMaxAllowedCodePoint(value) ? String.fromCodePoint(value) : "\uFFFD";
+}
+function consumeName(s) {
+  let result = "";
+  for (; ; ) {
+    if (isIdentCodePoint(s.peek())) {
+      result += consumeLiteralCodePoint(s);
+      continue;
+    }
+    if (!isValidEscapeAt(s)) return result;
+    s.advance();
+    result += consumeEscapedCodePoint(s);
+  }
+}
+
+// src/directive/tokenizer/url.ts
+var URL_BAD_DELIMITERS = /* @__PURE__ */ new Set(['"', "'", "("]);
+function isUrlBadCharacter(c) {
+  if (c !== void 0 && URL_BAD_DELIMITERS.has(c)) return true;
+  return isNonPrintable(c);
+}
+function consumeBadUrlRemnants(s) {
+  for (; ; ) {
+    if (s.eof()) return;
+    if (s.peek() === ")") {
+      s.advance();
+      return;
+    }
+    if (isValidEscapeAt(s)) {
+      s.advance();
+      consumeEscapedCodePoint(s);
+      continue;
+    }
+    s.advance();
+  }
+}
+function bad(s) {
+  consumeBadUrlRemnants(s);
+  return { value: "", bad: true };
+}
+function consumeUrlTrailingWhitespace(s, value) {
+  while (isWhitespace(s.peek())) s.advance();
+  if (s.eof()) return { value, bad: false };
+  if (s.peek() === ")") {
+    s.advance();
+    return { value, bad: false };
+  }
+  return bad(s);
+}
+function consumeUrlBackslash(s, value) {
+  if (isValidEscapeAt(s)) {
+    s.advance();
+    return { value: value + consumeEscapedCodePoint(s), bad: false };
+  }
+  return bad(s);
+}
+function consumeUrlToken(s) {
+  let value = "";
+  while (isWhitespace(s.peek())) s.advance();
+  for (; ; ) {
+    if (s.eof()) return { value, bad: false };
+    const c = s.peek();
+    if (c === ")") {
+      s.advance();
+      return { value, bad: false };
+    }
+    if (isWhitespace(c)) return consumeUrlTrailingWhitespace(s, value);
+    if (isUrlBadCharacter(c)) return bad(s);
+    if (c === "\\") {
+      const result = consumeUrlBackslash(s, value);
+      if (result.bad) return result;
+      value = result.value;
+      continue;
+    }
+    value += consumeLiteralCodePoint(s);
+  }
+}
+
+// src/directive/tokenizer/ident-like.ts
+function isFollowedByQuote(s) {
+  let lookahead = 0;
+  while (isWhitespace(s.peek(lookahead))) lookahead++;
+  const next = s.peek(lookahead);
+  return next === '"' || next === "'";
+}
+function consumeUrlOrFunctionToken(s, start) {
+  s.advance();
+  if (isFollowedByQuote(s)) {
+    return {
+      type: "function-token",
+      raw: s.input.slice(start, s.pos),
+      startIndex: start,
+      endIndex: s.pos,
+      structured: { value: "url" }
+    };
+  }
+  const { value, bad: bad2 } = consumeUrlToken(s);
+  return {
+    type: bad2 ? "bad-url-token" : "url-token",
+    raw: s.input.slice(start, s.pos),
+    startIndex: start,
+    endIndex: s.pos,
+    // eslint-disable-next-line unicorn/no-null -- the corpus's format carries null (not undefined) for a bad-url-token's structured field
+    structured: bad2 ? null : { value }
+  };
+}
+function consumeIdentLikeToken(s, start) {
+  const name = consumeName(s);
+  if (name.toLowerCase() === "url" && s.peek() === "(") {
+    return consumeUrlOrFunctionToken(s, start);
+  }
+  if (s.peek() === "(") {
+    s.advance();
+    return {
+      type: "function-token",
+      raw: s.input.slice(start, s.pos),
+      startIndex: start,
+      endIndex: s.pos,
+      structured: { value: name }
+    };
+  }
+  return {
+    type: "ident-token",
+    raw: s.input.slice(start, s.pos),
+    startIndex: start,
+    endIndex: s.pos,
+    structured: { value: name }
+  };
+}
+
+// src/directive/tokenizer/numeric.ts
+function consumeSign(s) {
+  const c = s.peek();
+  if (c !== "+" && c !== "-") return void 0;
+  s.advance();
+  return c;
+}
+function consumeDigitRun(s) {
+  let digits = "";
+  while (isDigit(s.peek())) {
+    digits += s.peek();
+    s.advance();
+  }
+  return digits;
+}
+function consumeFraction(s) {
+  if (s.peek() !== "." || !isDigit(s.peek(1))) return "";
+  s.advance();
+  return `.${consumeDigitRun(s)}`;
+}
+function consumeExponent(s) {
+  const e = s.peek();
+  if (e !== "e" && e !== "E") return "";
+  const afterE = s.peek(1);
+  const expSign = afterE === "+" || afterE === "-" ? afterE : "";
+  const digitsOffset = expSign ? 2 : 1;
+  if (!isDigit(s.peek(digitsOffset))) return "";
+  s.advance(digitsOffset);
+  return `${e}${expSign}${consumeDigitRun(s)}`;
+}
+function consumeNumber(s) {
+  const sign = consumeSign(s);
+  const integer = consumeDigitRun(s);
+  const fraction = consumeFraction(s);
+  const exponent = consumeExponent(s);
+  const repr = (sign ?? "") + integer + fraction + exponent;
+  const type = fraction || exponent ? "number" : "integer";
+  return { repr, value: Number(repr), type, sign };
+}
+function consumeNumericToken(s, start) {
+  const num = consumeNumber(s);
+  const signCharacter = num.sign ? { signCharacter: num.sign } : {};
+  if (isIdentSequenceStartAt(s)) {
+    const unit = consumeName(s);
+    const structured2 = {
+      value: num.value,
+      type: num.type,
+      unit,
+      ...signCharacter
+    };
+    return {
+      type: "dimension-token",
+      raw: s.input.slice(start, s.pos),
+      startIndex: start,
+      endIndex: s.pos,
+      structured: structured2
+    };
+  }
+  if (s.peek() === "%") {
+    s.advance();
+    const structured2 = { value: num.value, ...signCharacter };
+    return {
+      type: "percentage-token",
+      raw: s.input.slice(start, s.pos),
+      startIndex: start,
+      endIndex: s.pos,
+      structured: structured2
+    };
+  }
+  const structured = { value: num.value, type: num.type, ...signCharacter };
+  return {
+    type: "number-token",
+    raw: s.input.slice(start, s.pos),
+    startIndex: start,
+    endIndex: s.pos,
+    structured
+  };
+}
+
+// src/directive/tokenizer/string.ts
+var NEWLINE_CHARS = /* @__PURE__ */ new Set(["\n", "\r", "\f"]);
+function didConsumeLineContinuation(s) {
+  const c = s.peek(1);
+  if (c === void 0 || !NEWLINE_CHARS.has(c)) return false;
+  s.advance();
+  didConsumeNewline(s);
+  return true;
+}
+function consumeStringBackslash(s, value) {
+  if (s.eof(1)) {
+    s.advance();
+    return value;
+  }
+  if (didConsumeLineContinuation(s)) return value;
+  s.advance();
+  return value + consumeEscapedCodePoint(s);
+}
+function consumeStringToken(s, endingCodePoint) {
+  let value = "";
+  for (; ; ) {
+    if (s.eof()) return { value, bad: false };
+    const c = s.peek();
+    if (c === endingCodePoint) {
+      s.advance();
+      return { value, bad: false };
+    }
+    if (c !== void 0 && NEWLINE_CHARS.has(c)) {
+      return { value, bad: true };
+    }
+    if (c === "\\") {
+      value = consumeStringBackslash(s, value);
+      continue;
+    }
+    value += consumeLiteralCodePoint(s);
+  }
+}
+
+// src/directive/tokenizer.ts
+function delim(s, start, char) {
+  return {
+    type: "delim-token",
+    raw: char,
+    startIndex: start,
+    endIndex: s.pos,
+    structured: { value: char }
+  };
+}
+function noStructured(s, start, raw, type) {
+  return { type, raw, startIndex: start, endIndex: s.pos, structured: null };
+}
+var SIMPLE = {
+  ":": "colon-token",
+  ";": "semicolon-token",
+  ",": "comma-token",
+  "[": "[-token",
+  "]": "]-token",
+  "(": "(-token",
+  ")": ")-token",
+  "{": "{-token",
+  "}": "}-token"
+};
+function tryConsumeWhitespace(s, start, c) {
+  if (!isWhitespace(c)) return void 0;
+  while (isWhitespace(s.peek())) s.advance();
+  return noStructured(s, start, s.input.slice(start, s.pos), "whitespace-token");
+}
+function tryConsumeQuoted(s, start, c) {
+  if (c !== '"' && c !== "'") return void 0;
+  s.advance();
+  const { value, bad: bad2 } = consumeStringToken(s, c);
+  return {
+    type: bad2 ? "bad-string-token" : "string-token",
+    raw: s.input.slice(start, s.pos),
+    startIndex: start,
+    endIndex: s.pos,
+    // eslint-disable-next-line unicorn/no-null -- the corpus's own format carries null, not undefined, for a bad-string-token
+    structured: bad2 ? null : { value }
+  };
+}
+function consumeHashToken(s, start) {
+  const type = isIdentSequenceStartAt(s) ? "id" : "unrestricted";
+  const value = consumeName(s);
+  return {
+    type: "hash-token",
+    raw: s.input.slice(start, s.pos),
+    startIndex: start,
+    endIndex: s.pos,
+    structured: { value, type }
+  };
+}
+function tryConsumeHashOrDelim(s, start, c) {
+  if (c !== "#") return void 0;
+  s.advance();
+  if (isIdentCodePoint(s.peek()) || isValidEscapeAt(s)) return consumeHashToken(s, start);
+  return delim(s, start, c);
+}
+function tryConsumeSimple(s, start, c) {
+  const type = SIMPLE[c];
+  if (!type) return void 0;
+  s.advance();
+  return noStructured(s, start, c, type);
+}
+function tryConsumePlusOrDot(s, start, c) {
+  if (c !== "+" && c !== ".") return void 0;
+  if (isNumberStartAt(s)) return consumeNumericToken(s, start);
+  s.advance();
+  return delim(s, start, c);
+}
+function tryConsumeHyphen(s, start, c) {
+  if (c !== "-") return void 0;
+  if (isNumberStartAt(s)) return consumeNumericToken(s, start);
+  if (s.peek(1) === "-" && s.peek(2) === ">") {
+    s.advance(3);
+    return noStructured(s, start, s.input.slice(start, s.pos), "CDC-token");
+  }
+  if (isIdentSequenceStartAt(s)) return consumeIdentLikeToken(s, start);
+  s.advance();
+  return delim(s, start, c);
+}
+function tryConsumeLessThan(s, start, c) {
+  if (c !== "<") return void 0;
+  if (s.peek(1) === "!" && s.peek(2) === "-" && s.peek(3) === "-") {
+    s.advance(4);
+    return noStructured(s, start, s.input.slice(start, s.pos), "CDO-token");
+  }
+  s.advance();
+  return delim(s, start, c);
+}
+function tryConsumeAtKeyword(s, start, c) {
+  if (c !== "@") return void 0;
+  s.advance();
+  if (isIdentSequenceStartAt(s)) {
+    const value = consumeName(s);
+    return {
+      type: "at-keyword-token",
+      raw: s.input.slice(start, s.pos),
+      startIndex: start,
+      endIndex: s.pos,
+      structured: { value }
+    };
+  }
+  return delim(s, start, c);
+}
+function tryConsumeBackslash(s, start, c) {
+  if (c !== "\\") return void 0;
+  if (isValidEscapeAt(s)) return consumeIdentLikeToken(s, start);
+  s.advance();
+  return delim(s, start, c);
+}
+function tryConsumeDigitOrIdentStart(s, start, c) {
+  if (isDigit(c)) return consumeNumericToken(s, start);
+  if (isIdentStartCodePoint(c)) return consumeIdentLikeToken(s, start);
+  return void 0;
+}
+var DISPATCHERS = [
+  tryConsumeWhitespace,
+  tryConsumeQuoted,
+  tryConsumeHashOrDelim,
+  tryConsumeSimple,
+  tryConsumePlusOrDot,
+  tryConsumeHyphen,
+  tryConsumeLessThan,
+  tryConsumeAtKeyword,
+  tryConsumeBackslash,
+  tryConsumeDigitOrIdentStart
+];
+function nextToken(s, start) {
+  const comment = tryConsumeComment(s, start);
+  if (comment) return comment;
+  const c = s.peek();
+  for (const dispatch of DISPATCHERS) {
+    const token = dispatch(s, start, c);
+    if (token) return token;
+  }
+  s.advance();
+  return delim(s, start, c);
+}
+function tokenize(css) {
+  const s = new Scanner(css);
+  const tokens = [];
+  while (!s.eof()) {
+    tokens.push(nextToken(s, s.pos));
+  }
+  return tokens;
+}
+
+export { OPENERS, atKeywordName, createPositionFinder, isNaveAtKeyword, matchBrackets, readItem, reportDiagnostics, tokenize };