groove-dev 0.26.39 → 0.27.1

package/slides/node_modules/canvas/src/FontParser.cc

@@ -1,605 +0,0 @@
-// This is written to exactly parse the `font` shorthand in CSS2:
-// https://www.w3.org/TR/CSS22/fonts.html#font-shorthand
-// https://www.w3.org/TR/CSS22/syndata.html#tokenization
-//
-// We may want to update it for CSS 3 (e.g. font-stretch, or updated
-// tokenization) but I've only ever seen one or two issues filed in node-canvas
-// due to parsing in my 8 years on the project
-
-#include "FontParser.h"
-#include "CharData.h"
-#include <cctype>
-#include <unordered_map>
-
-Token::Token(Type type, std::string value) : type_(type), value_(std::move(value)) {}
-
-Token::Token(Type type, double value) : type_(type), value_(value) {}
-
-Token::Token(Type type) : type_(type), value_(std::string{}) {}
-
-const std::string&
-Token::getString() const {
-  static const std::string empty;
-  auto* str = std::get_if<std::string>(&value_);
-  return str ? *str : empty;
-}
-
-double
-Token::getNumber() const {
-  auto* num = std::get_if<double>(&value_);
-  return num ? *num : 0.0f;
-}
-
-Tokenizer::Tokenizer(std::string_view input) : input_(input) {}
-
-std::string
-Tokenizer::utf8Encode(uint32_t codepoint) {
-  std::string result;
-  
-  if (codepoint < 0x80) {
-    result += static_cast<char>(codepoint);
-  } else if (codepoint < 0x800) {
-    result += static_cast<char>((codepoint >> 6) | 0xc0);
-    result += static_cast<char>((codepoint & 0x3f) | 0x80);
-  } else if (codepoint < 0x10000) {
-    result += static_cast<char>((codepoint >> 12) | 0xe0);
-    result += static_cast<char>(((codepoint >> 6) & 0x3f) | 0x80);
-    result += static_cast<char>((codepoint & 0x3f) | 0x80);
-  } else {
-    result += static_cast<char>((codepoint >> 18) | 0xf0);
-    result += static_cast<char>(((codepoint >> 12) & 0x3f) | 0x80);
-    result += static_cast<char>(((codepoint >> 6) & 0x3f) | 0x80);
-    result += static_cast<char>((codepoint & 0x3f) | 0x80);
-  }
-  
-  return result;
-}
-
-char
-Tokenizer::peek() const {
-  return position_ < input_.length() ? input_[position_] : '\0';
-}
-
-char
-Tokenizer::advance() {
-  return position_ < input_.length() ? input_[position_++] : '\0';
-}
-
-Token
-Tokenizer::parseNumber() {
-  enum class State {
-    Start,
-    AfterSign,
-    Digits,
-    AfterDecimal,
-    AfterE,
-    AfterESign,
-    ExponentDigits
-  };
-
-  size_t start = position_;
-  size_t ePosition = 0;
-  State state = State::Start;
-  bool valid = false;
-  
-  while (position_ < input_.length()) {
-    char c = peek();
-    uint8_t flags = charData[static_cast<uint8_t>(c)];
-
-    switch (state) {
-      case State::Start:
-        if (flags & CharData::Sign) {
-          position_++;
-          state = State::AfterSign;
-        } else if (flags & CharData::Digit) {
-          position_++;
-          state = State::Digits;
-          valid = true;
-        } else if (c == '.') {
-          position_++;
-          state = State::AfterDecimal;
-        } else {
-          goto done;
-        }
-        break;
-
-      case State::AfterSign:
-        if (flags & CharData::Digit) {
-          position_++;
-          state = State::Digits;
-          valid = true;
-        } else if (c == '.') {
-          position_++;
-          state = State::AfterDecimal;
-        } else {
-          goto done;
-        }
-        break;
-
-      case State::Digits:
-        if (flags & CharData::Digit) {
-          position_++;
-        } else if (c == '.') {
-          position_++;
-          state = State::AfterDecimal;
-        } else if (c == 'e' || c == 'E') {
-          ePosition = position_;
-          position_++;
-          state = State::AfterE;
-          valid = false;
-        } else {
-          goto done;
-        }
-        break;
-
-      case State::AfterDecimal:
-        if (flags & CharData::Digit) {
-          position_++;
-          valid = true;
-          state = State::Digits;
-        } else {
-          goto done;
-        }
-        break;
-
-      case State::AfterE:
-        if (flags & CharData::Sign) {
-          position_++;
-          state = State::AfterESign;
-        } else if (flags & CharData::Digit) {
-          position_++;
-          valid = true;
-          state = State::ExponentDigits;
-        } else {
-          position_ = ePosition;
-          valid = true;
-          goto done;
-        }
-        break;
-
-      case State::AfterESign:
-        if (flags & CharData::Digit) {
-          position_++;
-          valid = true;
-          state = State::ExponentDigits;
-        } else {
-          position_ = ePosition;
-          valid = true;
-          goto done;
-        }
-        break;
-
-      case State::ExponentDigits:
-        if (flags & CharData::Digit) {
-          position_++;
-        } else {
-          goto done;
-        }
-        break;
-    }
-  }
-
-done:
-  if (!valid) {
-    position_ = start;
-    return Token(Token::Type::Invalid);
-  }
-
-  std::string number_str(input_.substr(start, position_ - start));
-  double value = std::stod(number_str);
-  return Token(Token::Type::Number, value);
-}
-
-// Note that identifiers are always lower-case. This helps us make easier/more
-// efficient comparisons, but means that font-families specified as identifiers
-// will be lower-cased. Since font selection isn't case sensitive, this
-// shouldn't ever be a problem.
-Token
-Tokenizer::parseIdentifier() {
-  std::string identifier;
-  auto flags = CharData::Nmstart;
-  auto start = position_;
-  
-  while (position_ < input_.length()) {
-    char c = peek();
-    
-    if (c == '\\') {
-      advance();
-      if (!parseEscape(identifier)) {
-        position_ = start;
-        return Token(Token::Type::Invalid);
-      }
-      flags = CharData::Nmchar;
-    } else if (charData[static_cast<uint8_t>(c)] & flags) {
-      identifier += advance() + (c >= 'A' && c <= 'Z' ? 32 : 0);
-      flags = CharData::Nmchar;
-    } else {
-      break;
-    }
-  }
-  
-  return Token(Token::Type::Identifier, identifier);
-}
-
-uint32_t
-Tokenizer::parseUnicode() {
-  uint32_t value = 0;
-  size_t count = 0;
-  
-  while (position_ < input_.length() && count < 6) {
-    char c = peek();
-    uint32_t digit;
-    
-    if (c >= '0' && c <= '9') {
-      digit = c - '0';
-    } else if (c >= 'a' && c <= 'f') {
-      digit = c - 'a' + 10;
-    } else if (c >= 'A' && c <= 'F') {
-      digit = c - 'A' + 10;
-    } else {
-      break;
-    }
-    
-    value = value * 16 + digit;
-    advance();
-    count++;
-  }
-  
-  // Optional whitespace after hex escape
-  char c = peek();
-  if (c == '\r') {
-    advance();
-    if (peek() == '\n') advance();
-  } else if (isWhitespace(c)) {
-    advance();
-  }
-  
-  return value;
-}
-
-bool
-Tokenizer::parseEscape(std::string& str) {
-  char c = peek();
-  auto flags = charData[static_cast<uint8_t>(c)];
-
-  if (flags & CharData::Hex) {
-    str += utf8Encode(parseUnicode());
-    return true;
-  } else if (!(flags & CharData::Newline) && !(flags & CharData::Hex)) {
-    str += advance();
-    return true;
-  }
-
-  return false;
-}
-
-Token
-Tokenizer::parseString(char quote) {
-  advance();
-  std::string value;
-  auto start = position_;
-  
-  while (position_ < input_.length()) {
-    char c = peek();
-    
-    if (c == quote) {
-      advance();
-      return Token(Token::Type::QuotedString, value);
-    } else if (c == '\\') {
-      advance();
-      c = peek();
-      if (c == '\r') {
-        advance();
-        if (peek() == '\n') advance();
-      } else if (isNewline(c)) {
-        advance();
-      } else {
-        if (!parseEscape(value)) {
-          position_ = start;
-          return Token(Token::Type::Invalid);
-        }
-      }
-    } else {
-      value += advance();
-    }
-  }
-
-  position_ = start;
-  return Token(Token::Type::Invalid);
-}
-
-Token
-Tokenizer::nextToken() {
-  if (position_ >= input_.length()) {
-    return Token(Token::Type::EndOfInput);
-  }
-
-  char c = peek();
-  auto flags = charData[static_cast<uint8_t>(c)];
-
-  if (isWhitespace(c)) {
-    std::string whitespace;
-    while (position_ < input_.length() && isWhitespace(peek())) {
-      whitespace += advance();
-    }
-    return Token(Token::Type::Whitespace, whitespace);
-  }
-
-  if (flags & CharData::NumStart) {
-    Token token = parseNumber();
-    if (token.type() != Token::Type::Invalid) return token;
-  }
-
-  if (flags & CharData::Nmstart) {
-    Token token = parseIdentifier();
-    if (token.type() != Token::Type::Invalid) return token;
-  }
-
-  if (c == '"') {
-    Token token = parseString('"');
-    if (token.type() != Token::Type::Invalid) return token;
-  }
-
-  if (c == '\'') {
-    Token token = parseString('\'');
-    if (token.type() != Token::Type::Invalid) return token;
-  }
-
-  switch (advance()) {
-    case '/': return Token(Token::Type::Slash);
-    case ',': return Token(Token::Type::Comma);
-    case '%': return Token(Token::Type::Percent);
-    default: return Token(Token::Type::Invalid);
-  }
-}
-
-FontParser::FontParser(std::string_view input)
-  : tokenizer_(input)
-  , currentToken_(tokenizer_.nextToken())
-  , nextToken_(tokenizer_.nextToken()) {}
-
-const std::unordered_map<std::string, uint16_t> FontParser::weightMap = {
-  {"normal", 400},
-  {"bold", 700},
-  {"lighter", 100},
-  {"bolder", 700}
-};
-
-const std::unordered_map<std::string, double> FontParser::unitMap = {
-  {"cm", 37.8f},
-  {"mm", 3.78f},
-  {"in", 96.0f},
-  {"pt", 96.0f / 72.0f},
-  {"pc", 96.0f / 6.0f},
-  {"em", 16.0f},
-  {"px", 1.0f}
-};
-
-void
-FontParser::advance() {
-  currentToken_ = nextToken_;
-  nextToken_ = tokenizer_.nextToken();
-}
-
-void
-FontParser::skipWs() {
-  while (currentToken_.type() == Token::Type::Whitespace) advance();
-}
-
-bool
-FontParser::check(Token::Type type) const {
-  return currentToken_.type() == type;
-}
-
-bool
-FontParser::checkWs() const {
-  return nextToken_.type() == Token::Type::Whitespace
-    || nextToken_.type() == Token::Type::EndOfInput;
-}
-
-bool
-FontParser::parseFontStyle(FontProperties& props) {
-  if (check(Token::Type::Identifier)) {
-    const auto& value = currentToken_.getString();
-    if (value == "italic") {
-      props.fontStyle = FontStyle::Italic;
-      advance();
-      return true;
-    } else if (value == "oblique") {
-      props.fontStyle = FontStyle::Oblique;
-      advance();
-      return true;
-    } else if (value == "normal") {
-      props.fontStyle = FontStyle::Normal;
-      advance();
-      return true;
-    }
-  }
-
-  return false;
-}
-
-bool
-FontParser::parseFontVariant(FontProperties& props) {
-  if (check(Token::Type::Identifier)) {
-    const auto& value = currentToken_.getString();
-    if (value == "small-caps") {
-      props.fontVariant = FontVariant::SmallCaps;
-      advance();
-      return true;
-    } else if (value == "normal") {
-      props.fontVariant = FontVariant::Normal;
-      advance();
-      return true;
-    }
-  }
-
-  return false;
-}
-
-bool
-FontParser::parseFontWeight(FontProperties& props) {
-  if (check(Token::Type::Number)) {
-    double weightFloat = currentToken_.getNumber();
-    int weight = static_cast<int>(weightFloat);
-    if (weight < 1 || weight > 1000) return false;
-    props.fontWeight = static_cast<uint16_t>(weight);
-    advance();
-    return true;
-  } else if (check(Token::Type::Identifier)) {
-    const auto& value = currentToken_.getString();
-
-    if (auto it = weightMap.find(value); it != weightMap.end()) {
-      props.fontWeight = it->second;
-      advance();
-      return true;
-    }
-  }
-
-  return false;
-}
-
-bool
-FontParser::parseFontSize(FontProperties& props) {
-  if (!check(Token::Type::Number)) return false;
-
-  props.fontSize = currentToken_.getNumber();
-  advance();
-
-  double multiplier = 1.0f;
-  if (check(Token::Type::Identifier)) {
-    const auto& unit = currentToken_.getString();
-
-    if (auto it = unitMap.find(unit); it != unitMap.end()) {
-      multiplier = it->second;
-      advance();
-    } else {
-      return false;
-    }
-  } else if (check(Token::Type::Percent)) {
-    multiplier = 16.0f / 100.0f;
-    advance();
-  } else {
-    return false;
-  }
-
-  // Technically if we consumed some tokens but couldn't parse the font-size,
-  // we should rewind the tokenizer, but I don't think the grammar allows for
-  // any valid alternates in this specific case
-
-  props.fontSize *= multiplier;
-  return true;
-}
-
-// line-height is not used by canvas ever, but should still parse
-bool
-FontParser::parseLineHeight(FontProperties& props) {
-  if (check(Token::Type::Slash)) {
-    advance();
-    skipWs();
-    if (check(Token::Type::Number)) {
-      advance();
-      if (check(Token::Type::Percent)) {
-        advance();
-      } else if (check(Token::Type::Identifier)) {
-        auto identifier = currentToken_.getString();
-        if (auto it = unitMap.find(identifier); it != unitMap.end()) {
-          advance();
-        } else {
-          return false;
-        }
-      } else {
-        return false;
-      }
-    } else if (check(Token::Type::Identifier) && currentToken_.getString() == "normal") {
-      advance();
-    } else {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-bool
-FontParser::parseFontFamily(FontProperties& props) {
-  while (!check(Token::Type::EndOfInput)) {
-    std::string family = "";
-    std::string trailingWs = "";
-    bool found = false;
-
-    while (
-      check(Token::Type::QuotedString) ||
-      check(Token::Type::Identifier) ||
-      check(Token::Type::Whitespace)
-    ) {
-      if (check(Token::Type::Whitespace)) {
-        if (found) trailingWs += currentToken_.getString();
-      } else { // Identifier, QuotedString
-        if (found) {
-          family += trailingWs;
-          trailingWs.clear();
-        }
-
-        family += currentToken_.getString();
-        found = true;
-      }
-
-      advance();
-    }
-
-    if (!found) return false; // only whitespace or non-id/string found
-
-    props.fontFamily.push_back(family);
-
-    if (check(Token::Type::Comma)) advance();
-  }
-
-  return true;
-}
-
-FontProperties
-FontParser::parse(const std::string& fontString, bool* success) {
-  FontParser parser(fontString);
-  auto result = parser.parseFont();
-  if (success) *success = !parser.hasError_;
-  return result;
-}
-
-FontProperties
-FontParser::parseFont() {
-  FontProperties props;
-  uint8_t state = 0b111;
-
-  skipWs();
-
-  for (size_t i = 0; i < 3 && checkWs(); i++) {
-    if ((state & 0b001) && parseFontStyle(props)) {
-      state &= 0b110;
-      goto match;
-    }
-
-    if ((state & 0b010) && parseFontVariant(props)) {
-      state &= 0b101;
-      goto match;
-    }
-
-    if ((state & 0b100) && parseFontWeight(props)) {
-      state &= 0b011;
-      goto match;
-    }
-
-    break; // all attempts exhausted
-    match: skipWs(); // success: move to the next non-ws token
-  }
-
-  if (parseFontSize(props)) {
-    skipWs();
-    if (parseLineHeight(props) && parseFontFamily(props)) {
-      return props;
-    }
-  }
-
-  hasError_ = true;
-  return props;
-}

package/slides/node_modules/canvas/src/FontParser.h

@@ -1,115 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-#include <optional>
-#include <memory>
-#include <variant>
-#include <unordered_map>
-#include "CharData.h"
-
-enum class FontStyle {
-  Normal,
-  Italic,
-  Oblique
-};
-
-enum class FontVariant {
-  Normal,
-  SmallCaps
-};
-
-struct FontProperties {
-  double fontSize{16.0f};
-  std::vector<std::string> fontFamily;
-  uint16_t fontWeight{400};
-  FontVariant fontVariant{FontVariant::Normal};
-  FontStyle fontStyle{FontStyle::Normal};
-};
-
-class Token {
-  public:
-    enum class Type {
-      Invalid,
-      Number,
-      Percent,
-      Identifier,
-      Slash,
-      Comma,
-      QuotedString,
-      Whitespace,
-      EndOfInput
-    };
-
-    Token(Type type, std::string value);
-    Token(Type type, double value);
-    Token(Type type);
-
-    Type type() const { return type_; }
-
-    const std::string& getString() const;
-    double getNumber() const;
-
-  private:
-    Type type_;
-    std::variant<std::string, double> value_;
-};
-
-class Tokenizer {
-  public:
-    Tokenizer(std::string_view input);
-    Token nextToken();
-
-  private:
-    std::string_view input_;
-    size_t position_{0};
-
-    // Util
-    std::string utf8Encode(uint32_t codepoint);
-    inline bool isWhitespace(char c) const {
-      return charData[static_cast<uint8_t>(c)] & CharData::Whitespace;
-    }
-    inline bool isNewline(char c) const {
-      return charData[static_cast<uint8_t>(c)] & CharData::Newline;
-    }
-
-    // Moving through the string
-    char peek() const;
-    char advance();
-
-    // Tokenize
-    Token parseNumber();
-    Token parseIdentifier();
-    uint32_t parseUnicode();
-    bool parseEscape(std::string& str);
-    Token parseString(char quote);
-};
-
-class FontParser {
-  public:
-    static FontProperties parse(const std::string& fontString, bool* success = nullptr);
-
-  private:
-    static const std::unordered_map<std::string, uint16_t> weightMap;
-    static const std::unordered_map<std::string, double> unitMap;
-
-    FontParser(std::string_view input);
-
-    void advance();
-    void skipWs();
-    bool check(Token::Type type) const;
-    bool checkWs() const;
-
-    bool parseFontStyle(FontProperties& props);
-    bool parseFontVariant(FontProperties& props);
-    bool parseFontWeight(FontProperties& props);
-    bool parseFontSize(FontProperties& props);
-    bool parseLineHeight(FontProperties& props);
-    bool parseFontFamily(FontProperties& props);
-    FontProperties parseFont();
-
-    Tokenizer tokenizer_;
-    Token currentToken_;
-    Token nextToken_;
-    bool hasError_{false};
-};