micromark Utility to Resolve Subtokens

Common errors

• ERR_REQUIRE_ESM: require() of ES Module ... micromark-util-resolve-all.js from ... not supported.

  cause Attempting to use `require()` to import `micromark-util-resolve-all` in a CommonJS environment.
  fix Ensure your project is configured for ESM, using `import` statements and setting `"type": "module"` in your `package.json`, or explicitly using `.mjs` file extensions. For Node.js, ensure you are running a compatible version (16+).

Warnings

• breaking Starting with version 2.0.0, micromark-util-resolve-all is an ESM-only package. Projects using CommonJS `require()` will encounter an `ERR_REQUIRE_ESM` error.
  Fix: Migrate your project to use ECMAScript Modules (ESM) with `import` statements, or stick to a previous major version if CommonJS is strictly required (though older versions might not be compatible with newer micromark releases).
• breaking Version 2.x of micromark-util-resolve-all requires Node.js 16 or higher. Older Node.js versions are not supported.
  Fix: Upgrade your Node.js environment to version 16 or newer. Refer to the Node.js official documentation for upgrade instructions.
• gotcha This package is an internal utility for the `micromark` parser. It's not typically intended for direct use by most developers. Directly depending on and using this package might couple your code too tightly to micromark's internal architecture, which can change in patch or minor releases without being considered a breaking change for external APIs.
  Fix: Unless you are developing a custom micromark extension at a very low level, consider using micromark's higher-level APIs or existing extensions instead of this utility directly.

Install

• npm install micromark-util-resolve-all npm
• yarn add micromark-util-resolve-all yarn
• pnpm add micromark-util-resolve-all pnpm

Imports

• resolveAll
  wrong:

  const resolveAll = require('micromark-util-resolve-all')

  correct:

  import { resolveAll } from 'micromark-util-resolve-all'

  This package is ESM-only since version 2.0.0. CommonJS `require()` is not supported.

Quickstart

This quickstart demonstrates how to use the `resolveAll` function by providing mock micromark events, constructs, and context. It shows how `resolveAll` orchestrates custom resolvers within constructs to process and transform the event stream, crucial for parsing non-linear Markdown syntax elements.

import { resolveAll } from 'micromark-util-resolve-all';

// These types are simplified for demonstration. In a real micromark setup,
// these would be imported from micromark-util-types and other micromark core packages.
type MicromarkEvent = [string, { type: string; start: { offset: number }; end: { offset: number }; [key: string]: any }];
type MicromarkConstruct = {
  resolveAll?: (events: MicromarkEvent[], context: MicromarkTokenizeContext) => MicromarkEvent[];
  [key: string]: any;
};
type MicromarkTokenizeContext = {
  parser: {
    constructs: {
      insideSpan: {
        null: MicromarkConstruct[];
      };
      [key: string]: any;
    };
  };
  // Other context properties would be here in a real scenario
  defineSkip: () => {};
  events: MicromarkEvent[];
  previous: number;
  sliceStream: (start: {offset: number}, end: {offset: number}) => string;
};

// 1. Define some dummy events. In micromark, these represent tokens parsed from Markdown.
const inputEvents: MicromarkEvent[] = [
  ['enter', { type: 'paragraph', start: { offset: 0 }, end: { offset: 0 } }],
  ['enter', { type: 'text', start: { offset: 0 }, end: { offset: 5 }, value: 'Hello' }],
  ['exit', { type: 'text', start: { offset: 0 }, end: { offset: 5 } }],
  ['enter', { type: 'strongSequence', start: { offset: 6 }, end: { offset: 8 }, _open: true }], // e.g., '**'
  ['enter', { type: 'text', start: { offset: 8 }, end: { offset: 13 }, value: 'World' }],
  ['exit', { type: 'text', start: { offset: 8 }, end: { offset: 13 } }],
  ['exit', { type: 'strongSequence', start: { offset: 13 }, end: { offset: 15 }, _close: true }], // e.g., '**'
  ['exit', { type: 'paragraph', start: { offset: 15 }, end: { offset: 15 } }],
];

// 2. Define dummy constructs. `resolveAll` takes a list of constructs, 
// some of which may contain their own `resolveAll` logic for post-processing.
const dummyConstructs: MicromarkConstruct[] = [
  {
    name: 'emphasis',
    resolveAll: (events: MicromarkEvent[], context: MicromarkTokenizeContext): MicromarkEvent[] => {
      console.log('  -> Custom emphasis resolver called within resolveAll. Events count:', events.length);
      // In a real scenario, this resolver would match openers and closers (like `*` or `**`)
      // and transform `attentionSequence` events into `emphasis` or `strong` nodes.
      return events.map(event => {
        if (event[1].type === 'strongSequence') {
          return [event[0], { ...event[1], type: 'strongToken' }];
        }
        return event;
      });
    }
  },
  { name: 'link' } // A construct without a custom `resolveAll`
];

// 3. Define a dummy context. In a real micromark parser, this object holds state.
const dummyContext: MicromarkTokenizeContext = {
  parser: { constructs: { insideSpan: { null: dummyConstructs } } },
  defineSkip: () => {},
  events: inputEvents, // Often, context.events would be the input events
  previous: -1,
  sliceStream: () => ''
};

console.log('--- Before resolveAll ---');
inputEvents.forEach(e => console.log(`  ${e[0].padEnd(5)} ${e[1].type}`));

// 4. Call `resolveAll` with the constructs, events, and context.
// It iterates through the provided constructs and calls their `resolveAll` methods.
const outputEvents = resolveAll(
  dummyContext.parser.constructs.insideSpan.null, // Typically operates on constructs relevant to inline content
  inputEvents,
  dummyContext
);

console.log('\n--- After resolveAll ---');
outputEvents.forEach(e => console.log(`  ${e[0].padEnd(5)} ${e[1].type}`));