sugar-high 1.3.0 → 2.0.0

package/lib/index.js

@@ -1,1017 +1,25 @@
 // @ts-check
 
-const JSXBrackets = new Set(['<', '>', '{', '}', '[', ']'])
-const Keywords_Js = new Set([
-  'for',
-  'do',
-  'while',
-  'if',
-  'else',
-  'return',
-  'function',
-  'var',
-  'let',
-  'const',
-  'true',
-  'false',
-  'undefined',
-  'this',
-  'new',
-  'delete',
-  'typeof',
-  'in',
-  'instanceof',
-  'void',
-  'break',
-  'continue',
-  'switch',
-  'case',
-  'default',
-  'throw',
-  'try',
-  'catch',
-  'finally',
-  'debugger',
-  'with',
-  'yield',
-  'async',
-  'await',
-  'class',
-  'extends',
-  'super',
-  'import',
-  'export',
-  'from',
-  'static',
-])
+import {
+  parse,
+  render,
+} from './core.js'
+import { languages } from './lang.js'
 
-const Keywords_Ts = new Set([
-  ...Keywords_Js,
-  'type',
-  'interface',
-  'enum',
-  'implements',
-  'readonly',
-  'abstract',
-  'declare',
-  'namespace',
-  'module',
-  'private',
-  'protected',
-  'public',
-  'override',
-  'keyof',
-  'infer',
-  'is',
-  'asserts',
-  'satisfies',
-  'as',
-  'unknown',
-  'never',
-  'any',
-  // Built-in type names (annotations / type positions)
-  'number',
-  'string',
-  'boolean',
-  'bigint',
-  'symbol',
-  'object',
-])
-
-const Signs = new Set([
-  '+',
-  '-',
-  '*',
-  '/',
-  '%',
-  '=',
-  '!',
-  '&',
-  '|',
-  '^',
-  '~',
-  '!',
-  '?',
-  ':',
-  '.',
-  ',',
-  ';',
-  `'`,
-  '"',
-  '.',
-  '(',
-  ')',
-  '[',
-  ']',
-  '#',
-  '@',
-  '\\',
-  ...JSXBrackets,
-])
-
-const DefaultOptions = {
-  keywords: Keywords_Js,
-  onCommentStart: isCommentStart_Js,
-  onCommentEnd: isCommentEnd_Js,
-}
-
-/**
- * Fast, heuristic TS detection. It intentionally prefers speed over full parsing.
- * @param {string} code
- * @returns {boolean}
- */
-function isLikelyTypeScript(code) {
-  let tsScore = 0
-
-  // TS-only declarations and operators.
-  if (/\binterface\s+[A-Za-z_$][\w$]*/.test(code)) tsScore += 2
-  if (/\btype\s+[A-Za-z_$][\w$]*\s*=/.test(code)) tsScore += 2
-  if (/\benum\s+[A-Za-z_$][\w$]*/.test(code)) tsScore += 2
-  if (/\b(?:implements|readonly|declare|namespace|satisfies|infer|keyof|asserts)\b/.test(code)) tsScore += 2
-
-  // Common TS annotations/signatures.
-  if (/:\s*[A-Za-z_$][\w$]*(?:<[^>\n]+>)?(?:\[\])?(?=\s*[,)=;{])/m.test(code)) tsScore += 1
-  if (/\b(?:const|let|var)\s+[A-Za-z_$][\w$]*\s*:\s*/.test(code)) tsScore += 1
-  if (/\)\s*:\s*[A-Za-z_$][\w$]*(?:<[^>\n]+>)?(?:\[\])?\s*(?:=>|\{)/.test(code)) tsScore += 1
-
-  return tsScore >= 2
-}
-
-/**
- * Detects `<T, U = ...>(` style generic parameter lists so they are not
- * treated as JSX tags.
- * @param {string} code
- * @param {number} startIndex
- * @returns {boolean}
- */
-function isTypeParameterListStart(code, startIndex) {
-  if (code[startIndex] !== '<') return false
-
-  let depth = 0
-  let sawIdentifierStart = false
-
-  for (let i = startIndex; i < code.length; i++) {
-    const ch = code[i]
-
-    if (ch === '<') {
-      depth++
-      continue
-    }
-    if (ch === '>') {
-      depth--
-      if (depth === 0) {
-        let next = i + 1
-        while (next < code.length && /\s/.test(code[next])) next++
-        if (!(sawIdentifierStart && code[next] === '(')) return false
-
-        // Focus this heuristic on generic arrow functions:
-        // const fn = <T>(arg) => ...
-        const tail = code.slice(next, next + 320)
-        return /\)\s*(?::[\s\S]{0,120}?)?=>/.test(tail)
-      }
-      continue
-    }
-    if (depth === 0) continue
-
-    if (/[$A-Za-z_]/.test(ch)) {
-      sawIdentifierStart = true
-      continue
-    }
-    if (/[\s,\.\=\?\:\|\&\[\]]/.test(ch)) continue
-
-    return false
-  }
-
-  return false
-}
-
-/**
- *
- * 0  - identifier
- * 1  - keyword
- * 2  - string
- * 3  - Class, number and null
- * 4  - property
- * 5  - entity
- * 6  - jsx literals
- * 7  - sign
- * 8  - comment
- * 9  - break
- * 10 - space
- *
- */
-const TokenTypes = /** @type {const} */ ([
-  'identifier',
-  'keyword',
-  'string',
-  'class',
-  'property',
-  'entity',
-  'jsxliterals',
-  'sign',
-  'comment',
-  'break',
-  'space',
-])
-const [
-  T_IDENTIFIER,
-  T_KEYWORD,
-  T_STRING,
-  T_CLS_NUMBER,
-  T_PROPERTY,
-  T_ENTITY,
-  T_JSX_LITERALS,
-  T_SIGN,
-  T_COMMENT,
-  T_BREAK,
-  T_SPACE,
-] = /** @types {const} */ TokenTypes.map((_, i) => i)
-
-function isSpaces(str) {
-  return /^[^\S\r\n]+$/g.test(str)
-}
-
-function isSign(ch) {
-  return Signs.has(ch)
-}
-
-const HtmlEntities = /** @type {Record<string, string>} */ ({
-  '&': '&amp;',
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  "'": '&#039;',
-})
-
-/** @param {string} str */
-function encode(str) {
-  if (!/[&<>"']/.test(str)) return str
-  return str.replace(/[&<>"']/g, chr => HtmlEntities[chr])
-}
-
-function isWord(chr) {
-  return /^[\w_]+$/.test(chr) || hasUnicode(chr)
-}
-
-function isCls(str) {
-  const chr0 = str[0]
-  return isWord(chr0) &&
-    chr0 === chr0.toUpperCase() ||
-    str === 'null'
-}
-
-function hasUnicode(s) {
-  return /[^\u0000-\u007f]/.test(s);
-}
-
-function isAlpha(chr) {
-  return /^[a-zA-Z]$/.test(chr)
-}
-
-function isIdentifierChar(chr) {
-  return isAlpha(chr) || hasUnicode(chr)
-}
-
-function isIdentifier(str) {
-  return isIdentifierChar(str[0]) && (str.length === 1 || isWord(str.slice(1)))
-}
-
-function isStrTemplateChr(chr) {
-  return chr === '`'
-}
-
-function isSingleQuotes(chr) {
-  return chr === '"' || chr === "'"
-}
-
-function isStringQuotation(chr) {
-  return isSingleQuotes(chr) || isStrTemplateChr(chr)
-}
-
-/** @returns {0|1|2}  */
-function isCommentStart_Js(curr, next) {
-  const str = curr + next
-  if (str === '/*') return 2
-  return str === '//' ? 1 : 0
-}
-
-/** @returns {0|1|2}  */
-function isCommentEnd_Js(prev, curr) {
-  return (prev + curr) === '*/'
-    ? 2
-    : curr === '\n' ? 1 : 0
-}
-
-function isRegexStart(str) {
-  return str[0] === '/' && !isCommentStart_Js(str[0], str[1])
-}
-
-function isPropertyKey(code, quoteEnd) {
-  let i = quoteEnd + 1
-  while (i < code.length && /\s/.test(code[i])) i++
-  return code[i] === ':'
-}
-
-/**
- * @param {string} code
- * @param {{
- *   keywords?: Set<string>
- *   typeKeywords?: Set<string>
- *   onCommentStart?: (curr: string, next: string) => number | boolean
- *   onCommentEnd?: (prev: string, curr: string) => number | boolean
- *   onQuote?: (curr: string, i: number, code: string) => number | null | undefined
- *   quotedKeys?: boolean
- *   lineClassName?: (line: string, index: number) => string | null | undefined
- * } | undefined} options
- * Optional `onQuote(curr, i, code)` at `code[i] === "'"`: return length to consume from `i` (>= 1),
- * or null/undefined/below 1 for default JS single-quoted strings. No substring allocation.
- * @return {Array<[number, string]>}
- */
-function tokenize(code, options) {
-  const mergedOptions = { ...DefaultOptions, ...options }
-  const hasCustomKeywords = !!(options && options.keywords instanceof Set)
-  const isTs = isLikelyTypeScript(code)
-  const resolvedKeywords = hasCustomKeywords
-    ? mergedOptions.keywords
-    : (isTs ? Keywords_Ts : Keywords_Js)
-
-  const {
-    onCommentStart,
-    onCommentEnd,
-  } = mergedOptions
-
-  const resolvedTypeKeywords =
-    mergedOptions.typeKeywords instanceof Set ? mergedOptions.typeKeywords : null
-
-  let current = ''
-  let type = -1
-  /** @type {[number, string]} */
-  let last = [-1, '']
-  /** @type {[number, string]} */
-  let beforeLast = [-2, '']
-  /** @type {Array<[number, string]>} */
-  const tokens = []
-
-  /**
-   * TS generics (`Map<string>`) and JSX (`<div>`) share the same `<Name …>` lexical shape. We use
-   * one tag-lexer mode (__jsxTag + __jsxStack) for both when we enter it; isTsTypeArgStart and
-   * isTypeParameterListStart only decide when *not* to enter (e.g. `foo<T>`, `<T>(x)=>`).
-   * __jsxEnter gates that mode so a latched __jsxTag (from `<` in `"a<b"`) does not run the tag
-   * lexer until we are in real JSX/TSX surface (not inside strings).
-   * @type {boolean}
-   */
-  let __jsxEnter = false
-  /** @type {0 | 1 | 2} 0 = none; 1 = inside `<open`; 2 = inside `</close` */
-  let __jsxTag = 0
-  let __jsxExpr = false
-
-  /** Nested `<open>…</open>` depth (content between tags, including nested elements). */
-  let __jsxStack = 0
-
-  const __jsxChild = () => __jsxEnter && !__jsxExpr && !__jsxTag
-  // < __content__ >
-  const inJsxTag = () => __jsxTag && !__jsxChild()
-  // {'__content__'}
-  const inJsxLiterals = () => !__jsxTag && __jsxChild() && !__jsxExpr && __jsxStack > 0
-
-  /** @type {string | null} */
-  let __strQuote = null
-  let __strTokenStart = 0
-  let __regexQuoteStart = false
-  let __strTemplateExprStack = 0
-  let __strTemplateQuoteStack = 0
-  const inStringQuotes = () => __strQuote !== null
-  const inRegexQuotes = () => __regexQuoteStart
-  const inStrTemplateLiterals = () => (__strTemplateQuoteStack > __strTemplateExprStack)
-  const inStrTemplateExpr = () => __strTemplateQuoteStack > 0 && (__strTemplateQuoteStack === __strTemplateExprStack)
-  const inStringContent = () => inStringQuotes() || inStrTemplateLiterals()
-
-  /**
-   *
-   * @param {string} token
-   * @returns {number}
-   */
-  function classify(token) {
-    const isLineBreak = token === '\n'
-    // First checking if they're attributes values
-    if (inJsxTag()) {
-      if (inStringQuotes()) {
-        return T_STRING
-      }
-
-      const [, lastToken] = last
-      if (isIdentifier(token)) {
-        // classify jsx open tag
-        if ((lastToken === '<' || lastToken === '</'))
-          return T_ENTITY
-      }
-    }
-    // Then determine if they're jsx literals
-    const isJsxLiterals = inJsxLiterals()
-    if (isJsxLiterals) return T_JSX_LITERALS
-
-    // Determine strings first before other types
-    if (inStringQuotes() || inStrTemplateLiterals()) {
-      return T_STRING
-    } else if (resolvedTypeKeywords && resolvedTypeKeywords.has(token)) {
-      return last[1] === '.' ? T_IDENTIFIER : T_CLS_NUMBER
-    } else if (resolvedKeywords.has(token)) {
-      return last[1] === '.' ? T_IDENTIFIER : T_KEYWORD
-    } else if (isLineBreak) {
-      return T_BREAK
-    } else if (isSpaces(token)) {
-      return T_SPACE
-    } else if (token.split('').every(isSign)) {
-      return T_SIGN
-    } else if (isCls(token)) {
-      return inJsxTag() ? T_IDENTIFIER : T_CLS_NUMBER
-    } else {
-      if (isIdentifier(token)) {
-        const isLastPropDot = last[1] === '.' && isIdentifier(beforeLast[1])
-
-        if (!inStringContent() && !isLastPropDot) return T_IDENTIFIER
-        if (isLastPropDot) return T_PROPERTY
-      }
-      return T_STRING
-    }
-  }
-
-  /**
-   *
-   * @param {number | undefined} [type_]
-   * @param {string | undefined} [token_]
-   */
-  const append = (type_, token_) => {
-    if (token_) {
-      current = token_
-    }
-    if (current) {
-      type = typeof type_ === 'number' ? type_ : classify(current)
-      /** @type [number, string]  */
-      const pair = [type, current]
-      if (type !== T_SPACE && type !== T_BREAK) {
-        beforeLast = last
-        last = pair
-      }
-      tokens.push(pair)
-    }
-    current = ''
-  }
-  for (let i = 0; i < code.length; i++) {
-    const curr = code[i]
-    const prev = code[i - 1]
-    const next = code[i + 1]
-    const p_c = prev + curr // previous and current
-    const c_n = curr + next // current and next
-
-    // onQuote(curr, i, code): length from i; end = i + len (capped).
-    if (
-      typeof mergedOptions.onQuote === 'function' &&
-      curr === "'" &&
-      !inStringQuotes() &&
-      !inJsxLiterals() &&
-      !inStrTemplateLiterals()
-    ) {
-      const rawLen = mergedOptions.onQuote(curr, i, code)
-      if (
-        typeof rawLen === 'number' &&
-        rawLen >= 1 &&
-        !Number.isNaN(rawLen)
-      ) {
-        const len = Math.min(rawLen, code.length - i)
-        const end = i + len
-        append()
-        current = code.slice(i, end)
-        append(T_IDENTIFIER)
-        i = end - 1
-        continue
-      }
-    }
-
-    // Determine string quotation outside of jsx literals and template literals.
-    // Inside jsx literals or template literals, string quotation is still part of it.
-    if (isSingleQuotes(curr) && !inJsxLiterals() && !inStrTemplateLiterals()) {
-      append()
-      let isStringClose = false
-      if (prev !== `\\`) {
-        if (__strQuote && curr === __strQuote) {
-          __strQuote = null
-          isStringClose = true
-        } else if (!__strQuote) {
-          __strQuote = curr
-          __strTokenStart = tokens.length
-        }
-      }
-
-      append(T_STRING, curr)
-      if (mergedOptions.quotedKeys && isStringClose && isPropertyKey(code, i)) {
-        for (let tokenIndex = __strTokenStart; tokenIndex < tokens.length; tokenIndex++) {
-          tokens[tokenIndex][0] = T_PROPERTY
-        }
-      }
-      continue
-    }
-
-    if (!inStrTemplateLiterals()) {
-      if (prev !== '\\n' && isStrTemplateChr(curr)) {
-        append()
-        append(T_STRING, curr)
-        __strTemplateQuoteStack++
-        continue
-      }
-    }
-
-    if (inStrTemplateLiterals()) {
-      if (prev !== '\\n' && isStrTemplateChr(curr)) {
-        if (__strTemplateQuoteStack > 0) {
-          append()
-          __strTemplateQuoteStack--
-          append(T_STRING, curr)
-          continue
-        }
-      }
-
-      if (c_n === '${') {
-        __strTemplateExprStack++
-        append(T_STRING)
-        append(T_SIGN, c_n)
-        i++
-        continue
-      }
-    }
-
-    if (inStrTemplateExpr() && curr === '}') {
-      append()
-      __strTemplateExprStack--
-      append(T_SIGN, curr)
-      continue
-    }
-
-    if (__jsxChild()) {
-      if (curr === '{') {
-        append()
-        append(T_SIGN, curr)
-        __jsxExpr = true
-        continue
-      }
-    }
-
-    if (__jsxEnter) {
-      // <: open tag sign
-      // new '<' not inside jsx
-      if (!__jsxTag && curr === '<') {
-        append()
-        if (next === '/') {
-          // close tag
-          __jsxTag = 2
-          current = c_n
-          i++
-        } else {
-          // open tag
-          __jsxTag = 1
-          current = curr
-        }
-        append(T_SIGN)
-        continue
-      }
-      if (__jsxTag) {
-        // >: open tag close sign or closing tag closing sign
-        // and it's not `=>` or `/>`
-        // `curr` could be `>` or `/`
-        if ((curr === '>' && !'/='.includes(prev))) {
-          append()
-          if (__jsxTag === 1) {
-            __jsxTag = 0
-            __jsxStack++
-          } else {
-            __jsxTag = 0
-            __jsxEnter = false
-          }
-          append(T_SIGN, curr)
-          continue
-        }
-
-        // >: tag self close sign or close tag sign
-        if (c_n === '/>' || c_n === '</') {
-          // if current token is not part of close tag sign, push it first
-          if (current !== '<' && current !== '/') {
-            append()
-          }
-
-          if (c_n === '/>') {
-            __jsxTag = 0
-          } else {
-            // is '</'
-            __jsxStack--
-          }
-
-          if (!__jsxStack)
-            __jsxEnter = false
-
-          current = c_n
-          i++
-          append(T_SIGN)
-          continue
-        }
-
-        // <: open tag sign
-        if (curr === '<') {
-          append()
-          current = curr
-          append(T_SIGN)
-          continue
-        }
-
-        // jsx property
-        // `-` in data-prop
-        if (next === '-'  && !inStringContent() && !inJsxLiterals()) {
-          if (current) {
-            append(T_PROPERTY, current + curr + next)
-            i++
-            continue
-          }
-        }
-        // `=` in property=<value>
-        if (next === '=' && !inStringContent()) {
-          // if current is not a space, ensure `prop` is a property
-          if (!isSpaces(curr)) {
-            // If there're leading spaces, append them first
-            if (isSpaces(current)) {
-              append()
-            }
-
-            // Now check if the accumulated token is a property
-            const prop = current + curr
-            if (isIdentifier(prop)) {
-              append(T_PROPERTY, prop)
-              continue
-            }
-          }
-        }
-      }
-    }
-
-    // if it's not in a jsx tag declaration or a string, close child if next is jsx close tag
-    if (!__jsxTag && (curr === '<' && isIdentifierChar(next) || c_n === '</')) {
-      let prevNonSpace = i - 1
-      while (prevNonSpace >= 0 && /\s/.test(code[prevNonSpace])) prevNonSpace--
-      const prevChar = prevNonSpace >= 0 ? code[prevNonSpace] : ''
-
-      const [lastType, lastTok] = last
-      // Without a space before `<`, the LHS is often still in `current` (not flushed), so `last` is stale.
-      let typeArgFromPending = false
-      let jsxFromPending = false
-      if (current && !isSpaces(current)) {
-        const w = current
-        // Unflushed LHS before `<`: numbers/null/Upper (isCls), and booleans, behave like `foo<` (type
-        // args / `<`). Any other keyword (`return`, `void`, …) is JSX-friendly — no keyword allowlist.
-        if (isCls(w) || w === 'true' || w === 'false') {
-          typeArgFromPending = true
-        } else if (resolvedKeywords.has(w) && isIdentifier(w)) {
-          jsxFromPending = true
-        } else if (isIdentifier(w)) {
-          typeArgFromPending = true
-        }
-      }
-
-      const isTsTypeArgStart =
-        curr === '<' &&
-        /[$\w\]\)]/.test(prevChar) &&
-        (typeArgFromPending ||
-          (!jsxFromPending &&
-            (lastType === T_IDENTIFIER ||
-              lastType === T_CLS_NUMBER ||
-              (lastType === T_SIGN && (lastTok === ')' || lastTok === ']')))))
-      const isTsGenericStart = curr === '<' && isTypeParameterListStart(code, i)
-      if (!isTsTypeArgStart && !isTsGenericStart) {
-        __jsxTag = next === '/' ? 2 : 1
-      }
-
-      if (curr === '<' && (next === '/' || isAlpha(next))) {
-        if (
-          !isTsTypeArgStart &&
-          !isTsGenericStart &&
-          !inStringContent() &&
-          !inJsxLiterals() &&
-          !inRegexQuotes()
-        ) {
-          __jsxEnter = true
-        }
-      }
-    }
-
-    const isQuotationChar = isStringQuotation(curr)
-    const isStringTemplateLiterals = inStrTemplateLiterals()
-    const isRegexChar = !__jsxEnter && isRegexStart(c_n)
-    const isJsxLiterals = inJsxLiterals()
-
-    // string quotation
-    if (isQuotationChar || isStringTemplateLiterals || isSingleQuotes(__strQuote)) {
-      current += curr
-    } else if (isRegexChar) {
-      append()
-      const [lastType, lastToken] = last
-      // Special cases that are not considered as regex:
-      // * (expr1) / expr2: `)` before `/` operator is still in expression
-      // * <non comment start>/ expr: non comment start before `/` is not regex
-      if (
-        isRegexChar &&
-        lastType !== -1 &&
-        !(
-          (lastType === T_SIGN && ')' !== lastToken) ||
-          lastType === T_COMMENT
-        )
-      ) {
-        current = curr
-        append()
-        continue
-      }
-
-      __regexQuoteStart = true
-      const start = i++
-
-      // end of line of end of file
-      const isEof = () => i >= code.length
-      const isEol = () => isEof() || code[i] === '\n'
-
-      let foundClose = false
-
-      // `/` is literal inside regex character classes, e.g. `[/]`.
-      let inCharClass = false
-
-      // traverse to find closing regex slash
-      for (; !isEol(); i++) {
-        const ch = code[i]
-        const escaped = code[i - 1] === '\\'
-        if (!escaped && ch === '[') inCharClass = true
-        if (!escaped && ch === ']') inCharClass = false
-        if (ch === '/' && !inCharClass && !escaped) {
-          foundClose = true
-          // end of regex, append regex flags
-          while (start !== i && /^[a-z]$/.test(code[i + 1]) && !isEol()) {
-            i++
-          }
-          break
-        }
-      }
-      __regexQuoteStart = false
-
-      if (start !== i && foundClose) {
-        // If current line is fully closed with string quotes or regex slashes,
-        // add them to tokens
-        current = code.slice(start, i + 1)
-        append(T_STRING)
-      } else {
-        // If it doesn't match any of the above, just leave it as operator and move on
-        current = curr
-        append()
-        i = start
-      }
-    } else if (onCommentStart(curr, next)) {
-      append()
-      const start = i
-      const startCommentType = onCommentStart(curr, next)
-
-      // just match the comment, commentType === true
-      // inline comment, commentType === 1
-      // block comment, commentType === 2
-      if (startCommentType) {
-        for (; i < code.length; i++) {
-          const endCommentType = onCommentEnd(code[i - 1], code[i])
-          if (endCommentType == startCommentType) break
-        }
-      }
-      current = code.slice(start, i + 1)
-      append(T_COMMENT)
-    } else if (curr === ' ' || curr === '\n') {
-      if (
-        curr === ' ' &&
-        (
-          (isSpaces(current) || !current) ||
-          isJsxLiterals
-        )
-      ) {
-        let end = i + 1
-        while (code[end] === ' ') end++
-        current += code.slice(i, end)
-        i = end - 1
-        if (code[end] === '<') {
-          append()
-        }
-      } else {
-        append()
-        current = curr
-        append()
-      }
-    } else {
-      if (__jsxExpr && curr === '}') {
-        append()
-        current = curr
-        append()
-        __jsxExpr = false
-      } else if (
-        // it's jsx literals and is not a jsx bracket
-        (isJsxLiterals && !JSXBrackets.has(curr)) ||
-        // it's template literal content (including quotes)
-        inStrTemplateLiterals() ||
-        // same type char as previous one in current token
-        ((isWord(curr) === isWord(current[current.length - 1]) || __jsxChild()) && !Signs.has(curr))
-      ) {
-        current += curr
-      } else {
-        if (p_c === '</') {
-          current = p_c
-        }
-        append()
-
-        if (p_c !== '</') {
-          current = curr
-
-        }
-        if ((c_n === '</' || c_n === '/>')) {
-          current = c_n
-          append()
-          i++
-        }
-        else if (JSXBrackets.has(curr)) append()
-      }
-    }
-  }
-
-  append()
-
-  return tokens
+/** @param {string | undefined} name */
+function configFor(name) {
+  return languages.find(({ id }) => id === (name || 'javascript'))?.config
 }
 
-/**
- * @param {Array<[number, string]>} tokens
- * @param {{
- *   lineClassName?: (line: string, index: number) => string | null | undefined
- * } | undefined} options
- * @return {Array<{type: string, tagName: string, children: any[], properties: Record<string, string>}>}
- */
-function generate(tokens, options) {
-  const lines = []
-  const lineClassName = options && typeof options.lineClassName === 'function'
-    ? options.lineClassName
-    : null
-  let lineIndex = 0
-  /**
-   * @param {any} children
-   * @param {string} text
-   * @return {{type: string, tagName: string, children: any[], properties: Record<string, string>}}
-   */
-  const createLine = (children, text) => {
-    const extraClassName = lineClassName ? lineClassName(text, lineIndex) : ''
-    lineIndex++
-
-    return ({
-        type: 'element',
-        tagName: 'span',
-        children,
-        properties: {
-          className: extraClassName ? `sh__line ${extraClassName}` : 'sh__line',
-        },
-      })
-  }
-
-  /**
-   * @param {Array<[number, string]>} tokens
-   * @returns {void}
-   */
-  function flushLine(tokens) {
-    const lineText = tokens.map(([, value]) => value).join('')
-    /** @type {Array<any>} */
-    const lineTokens = (
-      tokens
-        .map(([type, value]) => {
-          const tokenType = TokenTypes[type]
-          return {
-            type: 'element',
-            tagName: 'span',
-            children: [{
-              type: 'text', // text node
-              value, // to encode
-            }],
-            properties: {
-              className: `sh__token--${tokenType}`,
-              style: { color: `var(--sh-${tokenType})` },
-            },
-          }
-        })
-    )
-    lines.push(createLine(lineTokens, lineText))
-  }
-  /** @type {Array<[number, string]>} */
-  const lineTokens = []
-  let lastWasBreak = false
-
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i]
-    const [type, value] = token
-    const isLastToken = i === tokens.length - 1
-
-    if (type !== T_BREAK) {
-      // Divide multi-line token into multi-line code
-      if (value.includes('\n')) {
-        const lines = value.split('\n')
-        for (let j = 0; j < lines.length; j++) {
-          lineTokens.push([type, lines[j]])
-          if (j < lines.length - 1) {
-            flushLine(lineTokens)
-            lineTokens.length = 0
-          }
-        }
-      } else {
-        lineTokens.push(token)
-      }
-      lastWasBreak = false
-    } else {
-      if (lastWasBreak) {
-        // Consecutive break - create empty line
-        flushLine([])
-      } else {
-        // First break after content - flush current line
-        flushLine(lineTokens)
-        lineTokens.length = 0
-      }
-
-      // If this is the last token and it's a break, create an empty line
-      if (isLastToken) {
-        flushLine([])
-      }
-
-      lastWasBreak = true
-    }
-  }
-
-  // Flush remaining tokens if any
-  if (lineTokens.length) {
-    flushLine(lineTokens)
-  }
-
-  return lines
+/** @param {string} code @param {HighlightOptions | undefined} options */
+function highlight(code, options) {
+  const { lang, cx, mark, markLine } = options || {}
+  const parsed = parse(code, configFor(lang))
+  return render(parsed, { cx, mark, markLine })
 }
 
-/** @param {{ className: string, style?: Record<string, string> }} props */
-const propsToString = (props) => {
-  let str = `class="${props.className}"`
-
-  if (props.style) {
-    const style = Object.entries(props.style)
-      .map(([key, value]) => `${key}:${value}`)
-      .join(';')
-    str += ` style="${style}"`
-  }
-  return str
-}
-
-function toHtml(lines) {
-  return lines
-    .map(line => {
-      const { tagName: lineTag } = line
-      const tokens = line.children
-        .map(child => {
-          const { tagName, children, properties } = child
-          return `<${tagName} ${propsToString(properties)}>${encode(children[0].value)}</${tagName}>`
-        })
-        .join('')
-      return `<${lineTag} class="${line.properties.className}">${tokens}</${lineTag}>`
-    })
-    .join('\n')
-}
+export { highlight }
 
 /**
- *
- * @param {string} code
- * @param {{
- *   keywords?: Set<string>
- *   typeKeywords?: Set<string>
- *   onCommentStart?: (curr: string, next: string) => number | boolean
- *   onCommentEnd?: (curr: string, prev: string) => number | boolean
- *   onQuote?: (curr: string, i: number, code: string) => number | null | undefined
- *   quotedKeys?: boolean
- *   lineClassName?: (line: string, index: number) => string | null | undefined
- * } | undefined} options
- * `onQuote` same as `tokenize`.
- * @returns {string}
+ * @typedef {import('./core.js').DisplayOptions & { lang?: string }} HighlightOptions
  */
-function highlight(code, options) {
-  const tokens = tokenize(code, options)
-  const lines = generate(tokens, options)
-  const output = toHtml(lines)
-  return output
-}
-
-// namespace
-const SugarHigh = /** @type {const} */ {
-  TokenTypes,
-  TokenMap: new Map(TokenTypes.map((type, i) => [type, i])),
-}
-
-export {
-  highlight,
-  tokenize,
-  generate,
-  SugarHigh,
-}