banhaten 0.1.1 → 0.1.2

package/src/cli/index.js

@@ -409,13 +409,16 @@ async function writeGlobalCss(cwd, config, options) {
   const sourcePath = path.join(registryRoot, "styles", "globals.css")
   const tokenCss = await fs.readFile(sourcePath, "utf8")
   const current = await readTextIfExists(cssPath)
+  const tokenBlock = current
+    ? removeExistingTokenBlock(current, relative(cwd, cssPath))
+    : { content: "", found: false }
 
-  if (current?.includes(CSS_START) && !options.force) {
+  if (tokenBlock.found && !options.force) {
     return [`kept ${relative(cwd, cssPath)}`]
   }
 
   const nextCss = current
-    ? `${removeExistingTokenBlock(current).trimEnd()}\n\n${tokenCss}\n`
+    ? `${tokenBlock.content.trimEnd()}\n\n${tokenCss}\n`
     : `${tokenCss}\n`
   const next = ensureGlobalCssImports(nextCss)
 
@@ -489,20 +492,17 @@ async function writeViteAliasConfig(cwd, aliasRoot, options) {
 
   const current = await fs.readFile(viteConfigPath, "utf8")
   const sourceRoot = shouldUseSrcDirectory(cwd) ? "./src" : "."
-  const aliasLine = `"${aliasRoot}": fileURLToPath(new URL("${sourceRoot}", import.meta.url))`
+  let next
 
-  if (
-    current.includes(aliasLine) &&
-    current.includes("@tailwindcss/vite") &&
-    current.includes("tailwindcss()")
-  ) {
-    return [`kept ${relative(cwd, viteConfigPath)}`]
+  try {
+    next = updateViteConfigSource(current, { aliasRoot, sourceRoot })
+  } catch (error) {
+    throw new Error(`${relative(cwd, viteConfigPath)}: ${error.message}`)
   }
 
-  let next = ensureNodeUrlImport(current)
-  next = ensureTailwindViteImport(next)
-  next = addViteResolveAlias(next, aliasRoot, sourceRoot)
-  next = addVitePluginCall(next, "tailwindcss()")
+  if (next === current) {
+    return [`kept ${relative(cwd, viteConfigPath)}`]
+  }
 
   const status = await writeFile(viteConfigPath, next, {
     dryRun: options.dryRun,
@@ -528,50 +528,809 @@ async function findViteConfigPath(cwd) {
 }
 
 function ensureNodeUrlImport(source) {
-  if (source.includes("fileURLToPath") && source.includes("node:url")) return source
+  const imports = parseImportDeclarations(source)
+  const nodeUrlImports = imports.filter((entry) => entry.moduleSpecifier === "node:url")
+  const importedLocals = new Set(nodeUrlImports.flatMap((entry) => entry.namedLocals))
+  const missing = ["fileURLToPath", "URL"].filter((name) => !importedLocals.has(name))
+
+  if (missing.length === 0) return source
+
+  return prependImportLines(
+    source,
+    [`import { ${missing.join(", ")} } from "node:url"`]
+  )
+}
+
+function ensureTailwindViteImport(source, localName) {
+  const imports = parseImportDeclarations(source)
+  const tailwindImport = imports.find(
+    (entry) => entry.moduleSpecifier === "@tailwindcss/vite"
+  )
+
+  if (!tailwindImport) {
+    return prependImportLines(
+      source,
+      [`import ${localName} from "@tailwindcss/vite"`]
+    )
+  }
 
-  return `import { fileURLToPath, URL } from "node:url"\n${source}`
+  if (!tailwindImport.defaultLocal) {
+    throw new Error(
+      "unsupported Vite config: @tailwindcss/vite must be imported with a default binding."
+    )
+  }
+
+  return source
 }
 
-function ensureTailwindViteImport(source) {
-  if (source.includes("@tailwindcss/vite")) return source
+function updateViteConfigSource(source, { aliasRoot, sourceRoot }) {
+  const tailwindLocalName = getTailwindViteLocalName(source)
+  let next = addViteResolveAlias(source, aliasRoot, sourceRoot)
+  next = addVitePluginCall(next, `${tailwindLocalName}()`, tailwindLocalName)
+  next = ensureTailwindViteImport(next, tailwindLocalName)
+  next = ensureNodeUrlImport(next)
+  return next
+}
 
-  return `import tailwindcss from "@tailwindcss/vite"\n${source}`
+function getTailwindViteLocalName(source) {
+  const tailwindImport = parseImportDeclarations(source).find(
+    (entry) => entry.moduleSpecifier === "@tailwindcss/vite"
+  )
+
+  if (!tailwindImport) return "tailwindcss"
+  if (tailwindImport.defaultLocal) return tailwindImport.defaultLocal
+
+  throw new Error(
+    "unsupported Vite config: @tailwindcss/vite must be imported with a default binding."
+  )
 }
 
 function addViteResolveAlias(source, aliasRoot, sourceRoot) {
-  const aliasLine = `"${aliasRoot}": fileURLToPath(new URL("${sourceRoot}", import.meta.url))`
-  if (source.includes(aliasLine)) return source
-  if (!source.includes("defineConfig({")) return source
-
-  const resolveBlock = [
-    "  resolve: {",
-    "    alias: {",
-    `      "${aliasRoot}": fileURLToPath(new URL("${sourceRoot}", import.meta.url)),`,
-    "    },",
-    "  },",
-  ].join("\n")
-
-  return source.replace("defineConfig({", `defineConfig({\n${resolveBlock}`)
-}
-
-function addVitePluginCall(source, pluginCall) {
-  if (source.includes(pluginCall)) return source
-
-  const pluginsPattern = /plugins:\s*\[([\s\S]*?)\]/
-  if (pluginsPattern.test(source)) {
-    return source.replace(pluginsPattern, (_match, plugins) => {
-      const currentPlugins = plugins.trim().replace(/,\s*$/, "")
-      const nextPlugins = currentPlugins
-        ? `${currentPlugins}, ${pluginCall}`
-        : pluginCall
-      return `plugins: [${nextPlugins}]`
-    })
+  const configObject = findViteConfigObject(source)
+  const resolveProperty = findObjectProperty(source, configObject, "resolve")
+  const aliasEntry = `${JSON.stringify(aliasRoot)}: fileURLToPath(new URL(${JSON.stringify(
+    sourceRoot
+  )}, import.meta.url))`
+
+  if (!resolveProperty) {
+    return insertObjectProperty(
+      source,
+      configObject,
+      [
+        "resolve: {",
+        "  alias: {",
+        `    ${aliasEntry},`,
+        "  },",
+        "},",
+      ].join("\n")
+    )
+  }
+
+  const resolveObject = expectObjectLiteralValue(
+    source,
+    resolveProperty,
+    "unsupported Vite config: resolve must be an object literal."
+  )
+  const aliasProperty = findObjectProperty(source, resolveObject, "alias")
+
+  if (!aliasProperty) {
+    return insertObjectProperty(
+      source,
+      resolveObject,
+      [
+        "alias: {",
+        `  ${aliasEntry},`,
+        "},",
+      ].join("\n")
+    )
+  }
+
+  const aliasObject = expectObjectLiteralValue(
+    source,
+    aliasProperty,
+    "unsupported Vite config: resolve.alias must be an object literal."
+  )
+
+  if (findObjectProperty(source, aliasObject, aliasRoot)) {
+    return source
+  }
+
+  return insertObjectProperty(source, aliasObject, `${aliasEntry},`)
+}
+
+function addVitePluginCall(source, pluginCall, pluginLocalName) {
+  const configObject = findViteConfigObject(source)
+  const pluginsProperty = findObjectProperty(source, configObject, "plugins")
+
+  if (!pluginsProperty) {
+    return insertObjectProperty(source, configObject, `plugins: [${pluginCall}],`)
+  }
+
+  const pluginsArray = expectArrayLiteralValue(
+    source,
+    pluginsProperty,
+    "unsupported Vite config: plugins must be an array literal."
+  )
+
+  if (arrayHasCallExpression(source, pluginsArray, pluginLocalName)) {
+    return source
+  }
+
+  return appendArrayElement(source, pluginsArray, pluginCall)
+}
+
+function findViteConfigObject(source) {
+  const expressionStart = findExportDefaultExpressionStart(source)
+
+  if (expressionStart === -1) {
+    throw new Error(
+      "unsupported Vite config: expected `export default defineConfig({ ... })` or `export default { ... }`."
+    )
+  }
+
+  if (source[expressionStart] === "{") {
+    return createBracketRange(source, expressionStart, "{")
+  }
+
+  const callee = readIdentifierAt(source, expressionStart)
+  if (callee?.name !== "defineConfig") {
+    throw new Error(
+      "unsupported Vite config: default export must be `defineConfig({ ... })` or an object literal."
+    )
+  }
+
+  let index = skipWhitespaceAndComments(source, callee.end)
+  if (source[index] !== "(") {
+    throw new Error("unsupported Vite config: malformed defineConfig call.")
   }
 
-  if (!source.includes("defineConfig({")) return source
+  index = skipWhitespaceAndComments(source, index + 1)
+  if (source[index] !== "{") {
+    throw new Error(
+      "unsupported Vite config: defineConfig must receive a config object literal."
+    )
+  }
+
+  return createBracketRange(source, index, "{")
+}
+
+function findExportDefaultExpressionStart(source) {
+  let index = 0
 
-  return source.replace("defineConfig({", `defineConfig({\n  plugins: [${pluginCall}],`)
+  while (index < source.length) {
+    const next = skipIgnoredSyntax(source, index)
+    if (next !== index) {
+      index = next
+      continue
+    }
+
+    if (!matchIdentifier(source, index, "export")) {
+      index += 1
+      continue
+    }
+
+    const defaultStart = skipWhitespaceAndComments(source, index + "export".length)
+    if (!matchIdentifier(source, defaultStart, "default")) {
+      index += "export".length
+      continue
+    }
+
+    return skipWhitespaceAndComments(source, defaultStart + "default".length)
+  }
+
+  return -1
+}
+
+function createBracketRange(source, start, open) {
+  const close = open === "{" ? "}" : open === "[" ? "]" : ")"
+  const end = findMatchingBracket(source, start, open, close)
+  return { start, end: end + 1 }
+}
+
+function expectObjectLiteralValue(source, property, message) {
+  const valueStart = skipWhitespaceAndComments(source, property.valueStart)
+  if (source[valueStart] !== "{") throw new Error(message)
+  return createBracketRange(source, valueStart, "{")
+}
+
+function expectArrayLiteralValue(source, property, message) {
+  const valueStart = skipWhitespaceAndComments(source, property.valueStart)
+  if (source[valueStart] !== "[") throw new Error(message)
+  return createBracketRange(source, valueStart, "[")
+}
+
+function findObjectProperty(source, objectRange, propertyName) {
+  const bodyEnd = objectRange.end - 1
+  let index = objectRange.start + 1
+
+  while (index < bodyEnd) {
+    index = skipWhitespaceCommentsAndCommas(source, index, bodyEnd)
+    if (index >= bodyEnd) return null
+
+    const propertyStart = index
+    const name = readPropertyName(source, index)
+    const propertyEnd = findTopLevelCommaOrEnd(source, propertyStart, bodyEnd)
+
+    if (!name) {
+      index = propertyEnd + 1
+      continue
+    }
+
+    index = skipWhitespaceAndComments(source, name.end)
+    if (source[index] !== ":") {
+      if (name.name === propertyName) {
+        throw new Error(
+          `unsupported Vite config: ${propertyName} must be a normal object property.`
+        )
+      }
+      index = propertyEnd + 1
+      continue
+    }
+
+    if (name.name === propertyName) {
+      return {
+        name: name.name,
+        start: propertyStart,
+        end: propertyEnd,
+        valueStart: skipWhitespaceAndComments(source, index + 1),
+        valueEnd: propertyEnd,
+      }
+    }
+
+    index = propertyEnd + 1
+  }
+
+  return null
+}
+
+function readPropertyName(source, index) {
+  if (source[index] === "\"" || source[index] === "'") {
+    const literal = readStringLiteral(source, index)
+    return literal ? { name: literal.value, end: literal.end } : null
+  }
+
+  return readIdentifierAt(source, index)
+}
+
+function insertObjectProperty(source, objectRange, propertyText) {
+  const insertAt = objectRange.start + 1
+  const bodyEnd = objectRange.end - 1
+  const body = source.slice(insertAt, bodyEnd)
+  const hasContent = body.trim().length > 0
+  const propertyIndent = detectObjectChildIndent(source, objectRange)
+  const closeIndent = getLineIndent(source, bodyEnd)
+  const indentedProperty = indentMultiline(propertyText, propertyIndent)
+
+  if (!hasContent) {
+    return `${source.slice(0, insertAt)}\n${indentedProperty}\n${closeIndent}${source.slice(insertAt)}`
+  }
+
+  const needsTrailingNewline = source[insertAt] !== "\n" && source[insertAt] !== "\r"
+  const insertion = `\n${indentedProperty}${needsTrailingNewline ? "\n" : ""}`
+  return `${source.slice(0, insertAt)}${insertion}${source.slice(insertAt)}`
+}
+
+function detectObjectChildIndent(source, objectRange) {
+  const bodyEnd = objectRange.end - 1
+  let index = objectRange.start + 1
+
+  while (index < bodyEnd) {
+    if (source[index] === "\n") {
+      const next = skipHorizontalWhitespace(source, index + 1)
+      if (next < bodyEnd && source[next] !== "\n" && source[next] !== "\r") {
+        return source.slice(index + 1, next)
+      }
+    }
+    index += 1
+  }
+
+  return `${getLineIndent(source, objectRange.start)}  `
+}
+
+function appendArrayElement(source, arrayRange, elementText) {
+  const bodyStart = arrayRange.start + 1
+  const bodyEnd = arrayRange.end - 1
+  const body = source.slice(bodyStart, bodyEnd)
+
+  if (body.trim().length === 0) {
+    return `${source.slice(0, bodyStart)}${elementText}${source.slice(bodyStart)}`
+  }
+
+  const contentEnd = trimEndIndex(source, bodyStart, bodyEnd)
+  const hasNewline = bodyIncludesNewline(source, bodyStart, bodyEnd)
+  const hasTrailingComma = previousCodeChar(source, contentEnd) === ","
+
+  if (!hasNewline) {
+    const separator = hasTrailingComma ? " " : ", "
+    return `${source.slice(0, contentEnd)}${separator}${elementText}${source.slice(contentEnd)}`
+  }
+
+  const closeIndent = getLineIndent(source, bodyEnd)
+  const elementIndent = `${closeIndent}  `
+  const separator = hasTrailingComma ? "\n" : ",\n"
+  return `${source.slice(0, contentEnd)}${separator}${elementIndent}${elementText},${source.slice(contentEnd)}`
+}
+
+function arrayHasCallExpression(source, arrayRange, localName) {
+  const bodyEnd = arrayRange.end - 1
+  let index = arrayRange.start + 1
+
+  while (index < bodyEnd) {
+    index = skipWhitespaceCommentsAndCommas(source, index, bodyEnd)
+    if (index >= bodyEnd) return false
+
+    const elementEnd = findTopLevelCommaOrEnd(source, index, bodyEnd)
+    if (startsWithCallExpression(source, index, elementEnd, localName)) {
+      return true
+    }
+    index = elementEnd + 1
+  }
+
+  return false
+}
+
+function startsWithCallExpression(source, start, end, localName) {
+  const index = skipWhitespaceAndComments(source, start)
+  if (!matchIdentifier(source, index, localName)) return false
+
+  const callStart = skipWhitespaceAndComments(source, index + localName.length)
+  if (source[callStart] !== "(") return false
+
+  const callEnd = createBracketRange(source, callStart, "(").end
+  const next = skipWhitespaceAndComments(source, callEnd)
+  return next <= end
+}
+
+function parseImportDeclarations(source) {
+  const declarations = []
+  let index = 0
+
+  while (index < source.length) {
+    const next = skipIgnoredSyntax(source, index)
+    if (next !== index) {
+      index = next
+      continue
+    }
+
+    if (!matchIdentifier(source, index, "import")) {
+      index += 1
+      continue
+    }
+
+    const clauseStart = skipWhitespaceAndComments(source, index + "import".length)
+    if (source[clauseStart] === ".") {
+      index = clauseStart + 1
+      continue
+    }
+    if (source[clauseStart] === "(") {
+      index = clauseStart + 1
+      continue
+    }
+
+    const end = findImportDeclarationEnd(source, index)
+    const declaration = source.slice(index, end)
+    const moduleSpecifier = getImportModuleSpecifier(declaration)
+
+    if (moduleSpecifier) {
+      declarations.push({
+        start: index,
+        end,
+        moduleSpecifier,
+        defaultLocal: getDefaultImportLocal(declaration),
+        namedLocals: getNamedImportLocals(declaration),
+      })
+    }
+
+    index = end
+  }
+
+  return declarations
+}
+
+function findImportDeclarationEnd(source, start) {
+  const stack = []
+  let sawModuleSpecifier = false
+  let index = start
+
+  while (index < source.length) {
+    const skipped = skipComment(source, index)
+    if (skipped !== index) {
+      index = skipped
+      continue
+    }
+
+    if (source[index] === "\"" || source[index] === "'") {
+      const literal = readStringLiteral(source, index)
+      if (!literal) return source.length
+      sawModuleSpecifier = true
+      index = literal.end
+      continue
+    }
+
+    if (isOpeningBracket(source[index])) {
+      stack.push(expectedClosingBracket(source[index]))
+      index += 1
+      continue
+    }
+
+    if (isClosingBracket(source[index])) {
+      if (stack.at(-1) === source[index]) stack.pop()
+      index += 1
+      continue
+    }
+
+    if (stack.length === 0 && source[index] === ";") return index + 1
+    if (
+      stack.length === 0 &&
+      sawModuleSpecifier &&
+      (source[index] === "\n" || source[index] === "\r")
+    ) {
+      return index + 1
+    }
+
+    index += 1
+  }
+
+  return source.length
+}
+
+function getImportModuleSpecifier(declaration) {
+  let moduleSpecifier = null
+  let index = 0
+
+  while (index < declaration.length) {
+    const skipped = skipComment(declaration, index)
+    if (skipped !== index) {
+      index = skipped
+      continue
+    }
+
+    if (declaration[index] === "\"" || declaration[index] === "'") {
+      const literal = readStringLiteral(declaration, index)
+      if (!literal) break
+      moduleSpecifier = literal.value
+      index = literal.end
+      continue
+    }
+
+    index += 1
+  }
+
+  return moduleSpecifier
+}
+
+function getDefaultImportLocal(declaration) {
+  let index = skipWhitespaceAndComments(declaration, "import".length)
+
+  if (matchIdentifier(declaration, index, "type")) {
+    index = skipWhitespaceAndComments(declaration, index + "type".length)
+  }
+
+  if (declaration[index] === "\"" || declaration[index] === "{" || declaration[index] === "*") {
+    return null
+  }
+
+  const local = readIdentifierAt(declaration, index)
+  return local?.name ?? null
+}
+
+function getNamedImportLocals(declaration) {
+  const open = declaration.indexOf("{")
+  if (open === -1) return []
+
+  const close = findMatchingBracket(declaration, open, "{", "}")
+  const namedImportBody = declaration.slice(open + 1, close)
+  const locals = []
+
+  for (const specifier of splitTopLevelList(namedImportBody)) {
+    const trimmed = specifier.trim()
+    if (!trimmed) continue
+
+    const withoutType = trimmed.startsWith("type ")
+      ? trimmed.slice("type ".length).trim()
+      : trimmed
+    const asIndex = withoutType.toLowerCase().lastIndexOf(" as ")
+    const localName = asIndex === -1
+      ? withoutType
+      : withoutType.slice(asIndex + " as ".length).trim()
+    const local = readIdentifierAt(localName, 0)
+
+    if (local) locals.push(local.name)
+  }
+
+  return locals
+}
+
+function splitTopLevelList(source) {
+  const items = []
+  let start = 0
+  let index = 0
+
+  while (index < source.length) {
+    const skipped = skipIgnoredSyntax(source, index)
+    if (skipped !== index) {
+      index = skipped
+      continue
+    }
+
+    if (source[index] === ",") {
+      items.push(source.slice(start, index))
+      start = index + 1
+    }
+    index += 1
+  }
+
+  items.push(source.slice(start))
+  return items
+}
+
+function prependImportLines(source, lines) {
+  if (lines.length === 0) return source
+
+  let insertAt = 0
+  if (source.startsWith("#!")) {
+    const lineEnd = source.indexOf("\n")
+    insertAt = lineEnd === -1 ? source.length : lineEnd + 1
+  }
+
+  const prefix = `${lines.join("\n")}\n`
+  return `${source.slice(0, insertAt)}${prefix}${source.slice(insertAt)}`
+}
+
+function findTopLevelCommaOrEnd(source, start, end) {
+  const stack = []
+  let index = start
+
+  while (index < end) {
+    const next = skipIgnoredSyntax(source, index)
+    if (next !== index) {
+      index = next
+      continue
+    }
+
+    if (isOpeningBracket(source[index])) {
+      stack.push(expectedClosingBracket(source[index]))
+      index += 1
+      continue
+    }
+
+    if (isClosingBracket(source[index])) {
+      if (stack.at(-1) === source[index]) stack.pop()
+      index += 1
+      continue
+    }
+
+    if (stack.length === 0 && source[index] === ",") return index
+    index += 1
+  }
+
+  return end
+}
+
+function findMatchingBracket(source, start, open, close) {
+  if (source[start] !== open) {
+    throw new Error("unsupported Vite config: malformed JavaScript object.")
+  }
+
+  const stack = []
+  let index = start
+
+  while (index < source.length) {
+    const next = skipIgnoredSyntax(source, index)
+    if (next !== index) {
+      index = next
+      continue
+    }
+
+    if (isOpeningBracket(source[index])) {
+      stack.push(expectedClosingBracket(source[index]))
+      index += 1
+      continue
+    }
+
+    if (isClosingBracket(source[index])) {
+      const expected = stack.pop()
+      if (expected !== source[index]) {
+        throw new Error("unsupported Vite config: malformed JavaScript brackets.")
+      }
+      if (stack.length === 0) return index
+      index += 1
+      continue
+    }
+
+    index += 1
+  }
+
+  throw new Error(`unsupported Vite config: missing closing ${close}.`)
+}
+
+function skipIgnoredSyntax(source, index) {
+  const commentEnd = skipComment(source, index)
+  if (commentEnd !== index) return commentEnd
+
+  if (source[index] === "\"" || source[index] === "'" || source[index] === "`") {
+    return skipQuotedText(source, index)
+  }
+
+  return index
+}
+
+function skipComment(source, index) {
+  if (source[index] !== "/") return index
+
+  if (source[index + 1] === "/") {
+    const lineEnd = source.indexOf("\n", index + 2)
+    return lineEnd === -1 ? source.length : lineEnd + 1
+  }
+
+  if (source[index + 1] === "*") {
+    const blockEnd = source.indexOf("*/", index + 2)
+    return blockEnd === -1 ? source.length : blockEnd + 2
+  }
+
+  return index
+}
+
+function skipQuotedText(source, index) {
+  const quote = source[index]
+  index += 1
+
+  while (index < source.length) {
+    if (source[index] === "\\") {
+      index += 2
+      continue
+    }
+
+    if (source[index] === quote) return index + 1
+    index += 1
+  }
+
+  return source.length
+}
+
+function readStringLiteral(source, index) {
+  const quote = source[index]
+  if (quote !== "\"" && quote !== "'") return null
+
+  let value = ""
+  index += 1
+
+  while (index < source.length) {
+    if (source[index] === "\\") {
+      value += source[index + 1] ?? ""
+      index += 2
+      continue
+    }
+
+    if (source[index] === quote) {
+      return { value, end: index + 1 }
+    }
+
+    value += source[index]
+    index += 1
+  }
+
+  return null
+}
+
+function readIdentifierAt(source, index) {
+  if (!isIdentifierStart(source[index])) return null
+
+  let end = index + 1
+  while (end < source.length && isIdentifierPart(source[end])) {
+    end += 1
+  }
+
+  return { name: source.slice(index, end), end }
+}
+
+function matchIdentifier(source, index, name) {
+  if (source.slice(index, index + name.length) !== name) return false
+
+  const before = source[index - 1]
+  const after = source[index + name.length]
+  return !isIdentifierPart(before) && !isIdentifierPart(after)
+}
+
+function isIdentifierStart(char) {
+  return Boolean(char && /[A-Za-z_$]/.test(char))
+}
+
+function isIdentifierPart(char) {
+  return Boolean(char && /[A-Za-z0-9_$]/.test(char))
+}
+
+function isOpeningBracket(char) {
+  return char === "{" || char === "[" || char === "("
+}
+
+function isClosingBracket(char) {
+  return char === "}" || char === "]" || char === ")"
+}
+
+function expectedClosingBracket(char) {
+  if (char === "{") return "}"
+  if (char === "[") return "]"
+  return ")"
+}
+
+function skipWhitespaceAndComments(source, index) {
+  while (index < source.length) {
+    const next = skipComment(source, index)
+    if (next !== index) {
+      index = next
+      continue
+    }
+
+    if (!isWhitespace(source[index])) return index
+    index += 1
+  }
+
+  return index
+}
+
+function skipWhitespaceCommentsAndCommas(source, index, end) {
+  while (index < end) {
+    const next = skipWhitespaceAndComments(source, index)
+    if (next !== index) {
+      index = next
+      continue
+    }
+
+    if (source[index] !== ",") return index
+    index += 1
+  }
+
+  return index
+}
+
+function skipHorizontalWhitespace(source, index) {
+  while (source[index] === " " || source[index] === "\t") {
+    index += 1
+  }
+  return index
+}
+
+function isWhitespace(char) {
+  return char === " " || char === "\t" || char === "\n" || char === "\r"
+}
+
+function indentMultiline(text, indent) {
+  return text
+    .split("\n")
+    .map((line) => `${indent}${line}`)
+    .join("\n")
+}
+
+function getLineIndent(source, index) {
+  let lineStart = index
+  while (lineStart > 0 && source[lineStart - 1] !== "\n") {
+    lineStart -= 1
+  }
+
+  return source.slice(lineStart, skipHorizontalWhitespace(source, lineStart))
+}
+
+function trimEndIndex(source, start, end) {
+  while (end > start && isWhitespace(source[end - 1])) {
+    end -= 1
+  }
+  return end
+}
+
+function previousCodeChar(source, index) {
+  index -= 1
+  while (index >= 0 && isWhitespace(source[index])) {
+    index -= 1
+  }
+  return source[index]
+}
+
+function bodyIncludesNewline(source, start, end) {
+  for (let index = start; index < end; index += 1) {
+    if (source[index] === "\n" || source[index] === "\r") return true
+  }
+  return false
 }
 
 async function getPackageChanges(cwd, dependencies) {
@@ -734,9 +1493,76 @@ async function readJsonc(filePath) {
 }
 
 function stripJsonComments(content) {
-  return content
-    .replace(/\/\*[\s\S]*?\*\//g, "")
-    .replace(/(^|[^:])\/\/.*$/gm, "$1")
+  let output = ""
+  let inString = false
+  let escaped = false
+
+  for (let index = 0; index < content.length; index += 1) {
+    const char = content[index]
+    const next = content[index + 1]
+
+    if (inString) {
+      output += char
+
+      if (escaped) {
+        escaped = false
+      } else if (char === "\\") {
+        escaped = true
+      } else if (char === "\"") {
+        inString = false
+      }
+
+      continue
+    }
+
+    if (char === "\"") {
+      inString = true
+      output += char
+      continue
+    }
+
+    if (char === "/" && next === "/") {
+      output += "  "
+      index += 2
+
+      while (index < content.length && content[index] !== "\n" && content[index] !== "\r") {
+        output += " "
+        index += 1
+      }
+
+      if (index < content.length) {
+        output += content[index]
+        if (content[index] === "\r" && content[index + 1] === "\n") {
+          index += 1
+          output += content[index]
+        }
+      }
+
+      continue
+    }
+
+    if (char === "/" && next === "*") {
+      output += "  "
+      index += 2
+
+      while (index < content.length) {
+        if (content[index] === "*" && content[index + 1] === "/") {
+          output += "  "
+          index += 1
+          break
+        }
+
+        output += content[index] === "\n" || content[index] === "\r" ? content[index] : " "
+        index += 1
+      }
+
+      continue
+    }
+
+    output += char
+  }
+
+  return output
 }
 
 async function readJsonIfExists(filePath) {
@@ -766,27 +1592,136 @@ async function exists(filePath) {
   }
 }
 
-function removeExistingTokenBlock(content) {
-  const start = content.indexOf(CSS_START)
-  if (start === -1) return content
+function removeExistingTokenBlock(content, fileLabel = "CSS file") {
+  const lines = splitLinesPreservingEndings(content)
+  const kept = []
+  let found = false
+  let inTokenBlock = false
+
+  for (const line of lines) {
+    const trimmed = line.trimStart()
 
-  const end = content.indexOf(CSS_END, start)
-  if (end === -1) return content
+    if (trimmed.startsWith(CSS_START)) {
+      if (found || inTokenBlock) {
+        throw new Error(`${fileLabel}: multiple Banhaten token blocks found.`)
+      }
+      found = true
+      inTokenBlock = true
+      continue
+    }
 
-  return `${content.slice(0, start)}${content.slice(end + CSS_END.length)}`
+    if (trimmed.startsWith(CSS_END)) {
+      if (!inTokenBlock) {
+        throw new Error(`${fileLabel}: Banhaten token end marker has no start marker.`)
+      }
+      inTokenBlock = false
+      continue
+    }
+
+    if (!inTokenBlock) {
+      kept.push(line)
+    }
+  }
+
+  if (inTokenBlock) {
+    throw new Error(`${fileLabel}: Banhaten token block is missing its end marker.`)
+  }
+
+  return { content: kept.join(""), found }
 }
 
 function ensureGlobalCssImports(content) {
-  const fontImportPattern =
-    /^\s*@import\s+["']@fontsource(?:-variable)?\/inter(?:\/(?:400|500|600|700)\.css)?["'];\s*/gm
-  const tailwindImportPattern = /^\s*@import\s+["']tailwindcss["'];\s*/gm
-  const cleaned = content
-    .replace(fontImportPattern, "")
-    .replace(tailwindImportPattern, "")
+  const cleaned = splitLinesPreservingEndings(content)
+    .filter((line) => {
+      const importSpecifier = readCssImportSpecifier(line)
+      return (
+        importSpecifier !== "tailwindcss" &&
+        !isManagedInterFontImport(importSpecifier)
+      )
+    })
+    .join("")
     .trimStart()
   return `${TAILWIND_IMPORT}\n${FONT_IMPORTS.join("\n")}\n${cleaned}`
 }
 
+function splitLinesPreservingEndings(content) {
+  const lines = []
+  let lineStart = 0
+  let index = 0
+
+  while (index < content.length) {
+    if (content[index] === "\r" && content[index + 1] === "\n") {
+      lines.push(content.slice(lineStart, index + 2))
+      index += 2
+      lineStart = index
+      continue
+    }
+
+    if (content[index] === "\n") {
+      lines.push(content.slice(lineStart, index + 1))
+      index += 1
+      lineStart = index
+      continue
+    }
+
+    index += 1
+  }
+
+  if (lineStart < content.length) {
+    lines.push(content.slice(lineStart))
+  }
+
+  return lines
+}
+
+function readCssImportSpecifier(line) {
+  const trimmed = line.trim()
+  const importPrefix = "@import"
+  if (!trimmed.startsWith(importPrefix)) return null
+
+  let index = importPrefix.length
+  while (trimmed[index] === " " || trimmed[index] === "\t") {
+    index += 1
+  }
+
+  const quote = trimmed[index]
+  if (quote !== "\"" && quote !== "'") return null
+
+  const start = index + 1
+  index = start
+  while (index < trimmed.length && trimmed[index] !== quote) {
+    index += 1
+  }
+
+  if (index >= trimmed.length) return null
+  const specifier = trimmed.slice(start, index)
+  index += 1
+
+  while (trimmed[index] === " " || trimmed[index] === "\t") {
+    index += 1
+  }
+
+  if (trimmed[index] === ";") index += 1
+
+  while (trimmed[index] === " " || trimmed[index] === "\t") {
+    index += 1
+  }
+
+  return index === trimmed.length ? specifier : null
+}
+
+function isManagedInterFontImport(specifier) {
+  if (!specifier) return false
+  if (specifier === "@fontsource/inter") return true
+  if (specifier === "@fontsource-variable/inter") return true
+
+  for (const weight of ["400", "500", "600", "700"]) {
+    if (specifier === `@fontsource/inter/${weight}.css`) return true
+  }
+
+  return false
+}
+
 function appendAliasSegment(alias, segment) {
   if (!alias) return null
   return `${alias.replace(/\/$/, "")}/${segment}`