micromark Character Utilities

Common errors

• ERR_REQUIRE_ESM

  cause Attempting to import an ESM-only package using CommonJS `require()` syntax.
  fix Change `const { asciiAlpha } = require('micromark-util-character')` to `import { asciiAlpha } from 'micromark-util-character'`.

• TypeError: Cannot read properties of undefined (reading 'charCodeAt')

  cause Passing `null` or `undefined` as a character code to a utility function.
  fix Ensure the input to character utility functions is always a valid number representing a character code. Add checks for `null` or `undefined` if the source of the code is untrustworthy.

• Property 'asciiAlpha' does not exist on type 'typeof import("micromark-util-character")'.

  cause Attempting to use a non-existent export or incorrect named import for a utility function.
  fix Verify the exact name of the imported function and ensure it is correctly destructured from the named exports, e.g., `import { asciiAlpha } from 'micromark-util-character'`.

Warnings

• breaking The package transitioned to being ESM-only. CommonJS `require()` statements will no longer work and will result in errors.
  Fix: Migrate your import statements to use ES modules syntax: `import { functionName } from 'micromark-util-character'`.
• breaking Version 2.1.0 included updates for 'CM 0.31' and added Unicode symbols for attention. While not explicitly detailed as breaking, changes related to character attention and CommonMark versions can subtly alter parsing behavior if custom extensions relied on previous interpretations.
  Fix: Review any custom micromark extensions that interact closely with character classification, especially for Unicode characters or 'attention' mechanisms, and test thoroughly with the new version.
• gotcha The utility functions expect character *codes* (numbers), not character *strings*. Passing a string will result in incorrect behavior or runtime errors.
  Fix: Always convert characters to their code points using `String.prototype.charCodeAt(0)` before passing them to these utility functions.
• gotcha Be mindful of the distinction between 'ASCII' and 'Unicode' prefixed functions. Functions like `asciiAlpha` only check within the ASCII range, while `unicodePunctuation` and `unicodeWhitespace` handle a broader set of characters. Using an ASCII-only check for non-ASCII input will yield false results.
  Fix: Choose the appropriate utility function based on the character set you intend to handle. For broader internationalization, prefer `unicode*` checks where available or implement custom logic.

Install

• npm install micromark-util-character npm
• yarn add micromark-util-character yarn
• pnpm add micromark-util-character pnpm

Imports

• asciiAlpha
  wrong:

  const { asciiAlpha } = require('micromark-util-character')

  correct:

  import { asciiAlpha } from 'micromark-util-character'

  micromark-util-character is an ESM-only package since v1. Named imports are required as there is no default export.
• markdownLineEnding
  wrong:

  import markdownLineEnding from 'micromark-util-character'

  correct:

  import { markdownLineEnding } from 'micromark-util-character'

  Only named exports are available; there is no default export from this module.
• unicodeWhitespace
  wrong:

  const unicodeWhitespace = require('micromark-util-character').unicodeWhitespace

  correct:

  import { unicodeWhitespace } from 'micromark-util-character'

  Ensure you are using named imports for ESM modules. Direct property access on a require result will fail.

Quickstart

This quickstart demonstrates how to use several utility functions to check character codes for various properties, such as being an ASCII alpha, Markdown line ending, or Unicode punctuation. It also shows a simple custom function combining these utilities.

import { asciiAlpha, markdownLineEnding, unicodePunctuation, asciiDigit } from 'micromark-util-character';

console.log('--- Character Checks ---');

const charA = 65; // 'A'
const charNewline = 10; // '\n'
const charAmpersand = 38; // '&'
const charDigit = 50; // '2'
const charSpace = 32; // ' '
const charUnicodePunctuation = 8212; // '—' (em dash)

console.log(`Is '${String.fromCharCode(charA)}' an ASCII alpha character? ${asciiAlpha(charA)}`);
console.log(`Is '${String.fromCharCode(charNewline)}' a Markdown line ending? ${markdownLineEnding(charNewline)}`);
console.log(`Is '${String.fromCharCode(charAmpersand)}' a Unicode punctuation character? ${unicodePunctuation(charAmpersand)}`);
console.log(`Is '${String.fromCharCode(charDigit)}' an ASCII digit character? ${asciiDigit(charDigit)}`);
console.log(`Is '${String.fromCharCode(charSpace)}' a Markdown space? ${markdownLineEnding(charSpace)}`);
console.log(`Is '${String.fromCharCode(charUnicodePunctuation)}' a Unicode punctuation character? ${unicodePunctuation(charUnicodePunctuation)}`);

// Demonstrating a common pattern for custom parsers:
function isStartOfWord(code) {
  return asciiAlpha(code) || asciiDigit(code);
}

const testCode = 'H'.charCodeAt(0);
console.log(`Is '${String.fromCharCode(testCode)}' a start of word? ${isStartOfWord(testCode)}`);