@intlayer/core 9.4.3 → 9.5.0

package/dist/types/localization/proxyMode.d.ts

@@ -13,7 +13,7 @@
  * - `'disabled'` — the option was explicitly set to `false`. The proxy is not
  *   registered at all (Vite) or becomes a pass-through (Next.js).
  */
-type ProxyMode = 'auto' | 'forced' | 'disabled';
+export type ProxyMode = 'auto' | 'forced' | 'disabled';
 /**
  * Resolves the effective {@link ProxyMode} from the `routing.enableProxy`
  * configuration value.
@@ -34,7 +34,7 @@ type ProxyMode = 'auto' | 'forced' | 'disabled';
  * resolveProxyMode(false);     // 'disabled'
  * ```
  */
-declare const resolveProxyMode: (enableProxy?: boolean) => ProxyMode;
+export declare const resolveProxyMode: (enableProxy?: boolean) => ProxyMode;
 /**
  * Indicates whether the proxy may use the locale held in storage (cookie or
  * header) as a source when deciding which locale a request resolves to.
@@ -59,7 +59,7 @@ declare const resolveProxyMode: (enableProxy?: boolean) => ProxyMode;
  * isProxyStorageLocaleEnabled('forced', true);  // true  — explicitly opted in
  * ```
  */
-declare const isProxyStorageLocaleEnabled: (proxyMode: ProxyMode, isDevServer: boolean) => boolean;
+export declare const isProxyStorageLocaleEnabled: (proxyMode: ProxyMode, isDevServer: boolean) => boolean;
 /**
  * Builds the line announcing that a server has mounted the locale-routing
  * proxy.
@@ -86,7 +86,6 @@ declare const isProxyStorageLocaleEnabled: (proxyMode: ProxyMode, isDevServer: b
  * // Intlayer proxy enabled
  * ```
  */
-declare const formatProxyEnabledMessage: (isStorageLocaleSuppressed: boolean) => string;
+export declare const formatProxyEnabledMessage: (isStorageLocaleSuppressed: boolean) => string;
 //#endregion
-export { ProxyMode, formatProxyEnabledMessage, isProxyStorageLocaleEnabled, resolveProxyMode };
 //# sourceMappingURL=proxyMode.d.ts.map

package/dist/types/localization/proxyMode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proxyMode.d.ts","names":[],"sources":["../../../src/localization/proxyMode.ts"],"mappings":";;;;;;;;;;;;;;;KAiBY;;;;;;;;;;;;;;;;;;;;;cAsBC,mBAAgB,0BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;cAkC5C,8BAA2B,WAC3B,WAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BT,4BAAyB"}
+{"version":3,"file":"proxyMode.d.ts","names":[],"sources":["../../../src/localization/proxyMode.ts"],"mappings":";;;;;;;;;;;;;;;YAiBY;;;;;;;;;;;;;;;;;;;;;qBAsBC,mBAAgB,0BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;qBAkC5C,8BAA2B,WAC3B,WAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8BT,4BAAyB"}

package/dist/types/localization/resolveBrowserLocale.d.ts

@@ -15,7 +15,7 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * @param options - Routing overrides, defaulting to the built configuration.
  * @returns The resolved locale, falling back to the default locale off-browser.
  */
-declare const resolveBrowserLocale: (options?: RoutingOptions) => LocalesValues;
+export declare const resolveBrowserLocale: (options?: RoutingOptions) => LocalesValues;
 /**
  * {@link resolveBrowserLocale}, memoized for the current URL.
  *
@@ -29,7 +29,6 @@ declare const resolveBrowserLocale: (options?: RoutingOptions) => LocalesValues;
  * chunks with that locale, instead of preloading the old one and silently
  * falling back to an asynchronous read.
  */
-declare const getPreloadLocale: () => LocalesValues;
+export declare const getPreloadLocale: () => LocalesValues;
 //#endregion
-export { getPreloadLocale, resolveBrowserLocale };
 //# sourceMappingURL=resolveBrowserLocale.d.ts.map

package/dist/types/localization/resolveBrowserLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/resolveBrowserLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;cAoBa,uBAAoB,UACrB,mBACT;;;;;;;;;;;;;;cAqDU,wBAAuB"}
+{"version":3,"file":"resolveBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/resolveBrowserLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAoBa,uBAAoB,UACrB,mBACT;;;;;;;;;;;;;;qBAqDU,wBAAuB"}

package/dist/types/localization/rewriteMatch.d.ts

@@ -6,15 +6,14 @@ import { RewriteObject, RewriteRules, RoutingConfig } from "@intlayer/types/conf
  * Idempotent: already-normalized rules are handed back untouched, so a caller
  * holding resolved rules can pass them on without re-normalizing.
  */
-declare const getRewriteRules: <const Context extends keyof RewriteObject = 'url'>(rewrite: RoutingConfig['rewrite'] | RewriteRules, context?: Context) => RewriteRules | undefined;
+export declare const getRewriteRules: <const Context extends keyof RewriteObject = 'url'>(rewrite: RoutingConfig['rewrite'] | RewriteRules, context?: Context) => RewriteRules | undefined;
 /**
  * Replaces route parameters in a path with provided values.
  */
-declare const fillPath: (pattern: string, params: string[]) => string;
+export declare const fillPath: (pattern: string, params: string[]) => string;
 /**
  * Extract values from a URL based on a pattern.
  */
-declare const extractParams: (url: string, pattern: string) => string[] | null;
+export declare const extractParams: (url: string, pattern: string) => string[] | null;
 //#endregion
-export { extractParams, fillPath, getRewriteRules };
 //# sourceMappingURL=rewriteMatch.d.ts.map

package/dist/types/localization/rewriteMatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rewriteMatch.d.ts","names":[],"sources":["../../../src/localization/rewriteMatch.ts"],"mappings":";;;;;;;;cAYa,wBACL,sBAAsB,uBAAqB,SAExC,2BAA2B,cAAY,UACvC,YACR;;;;cA+DU,WAAQ,iBAAmB;;;;cAa3B,gBAAa,aACb"}
+{"version":3,"file":"rewriteMatch.d.ts","names":[],"sources":["../../../src/localization/rewriteMatch.ts"],"mappings":";;;;;;;;qBAYa,wBACL,sBAAsB,uBAAqB,SAExC,2BAA2B,cAAY,UACvC,YACR;;;;qBA+DU,WAAQ,iBAAmB;;;;qBAa3B,gBAAa,aACb"}

package/dist/types/localization/rewriteUtils.d.ts

@@ -8,7 +8,7 @@ import { RewriteRules, RoutingConfig } from "@intlayer/types/config";
  * input that was passed in, so a literal input keeps its literal type. Only a
  * rewritten path is computed at runtime and therefore widens to `string`.
  */
-type LocalizedPathResult<CanonicalPath extends string = string> = {
+export type LocalizedPathResult<CanonicalPath extends string = string> = {
   path: CanonicalPath;
   isRewritten: false;
 } | {
@@ -31,7 +31,7 @@ type WithLeadingSlash<Path extends string> = Path extends `/${string}` ? Path :
  * type B = InternalPath<'/', 'fr'>;         // '/fr'
  * type C = InternalPath<'/fr/about', 'fr'>; // '/fr/about' (already prefixed)
  */
-type InternalPath<Path extends string, Locale extends string> = string extends Path ? string : WithLeadingSlash<Path> extends (infer Prefixed extends string) ? Prefixed extends `/${Locale}` | `/${Locale}/${string}` ? Prefixed : Prefixed extends '/' ? `/${Locale}` : `/${Locale}${Prefixed}` : never;
+export type InternalPath<Path extends string, Locale extends string> = string extends Path ? string : WithLeadingSlash<Path> extends (infer Prefixed extends string) ? Prefixed extends `/${Locale}` | `/${Locale}/${string}` ? Prefixed : Prefixed extends '/' ? `/${Locale}` : `/${Locale}${Prefixed}` : never;
 /**
  * Given a canonical path (e.g., "/products/123"), finds the localized URL pattern
  * (e.g., "/produits/123") and reports whether a rule actually matched.
@@ -46,16 +46,15 @@ type InternalPath<Path extends string, Locale extends string> = string extends P
  * @param rewriteRules - Normalized rules, as returned by {@link getRewriteRules}.
  * @returns The localized path, discriminated on whether a rewrite rule matched.
  */
-declare const resolveLocalizedPath: <const CanonicalPath extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(canonicalPath: CanonicalPath, locale?: Locale, rewriteRules?: RewriteRules) => LocalizedPathResult<CanonicalPath>;
+export declare const resolveLocalizedPath: <const CanonicalPath extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(canonicalPath: CanonicalPath, locale?: Locale, rewriteRules?: RewriteRules) => LocalizedPathResult<CanonicalPath>;
 /**
  * Returns the internal path for a given canonical path and locale.
  * Ensures the locale prefix is present exactly once.
  */
-declare const getInternalPath: <const Path extends string, const Locale extends LocalesValues>(canonicalPath: Path, locale: Locale) => InternalPath<Path, Locale>;
+export declare const getInternalPath: <const Path extends string, const Locale extends LocalesValues>(canonicalPath: Path, locale: Locale) => InternalPath<Path, Locale>;
 /**
  * Given a current pathname and locale, returns the pretty localized path if a rewrite rule exists and the path is not already localized.
  */
-declare const getRewritePath: <const Path extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(pathname: Path, locale: Locale, rewrite?: RoutingConfig['rewrite']) => string | undefined;
+export declare const getRewritePath: <const Path extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(pathname: Path, locale: Locale, rewrite?: RoutingConfig['rewrite']) => string | undefined;
 //#endregion
-export { InternalPath, LocalizedPathResult, getInternalPath, getRewritePath, resolveLocalizedPath };
 //# sourceMappingURL=rewriteUtils.d.ts.map

package/dist/types/localization/rewriteUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rewriteUtils.d.ts","names":[],"sources":["../../../src/localization/rewriteUtils.ts"],"mappings":";;;;;;;;;;KAgBY,oBAAoB;EAC1B,MAAM;EAAe;;EACrB;EAAc;;;KAGf,iBAAiB,uBAAuB,4BACzC,WACI;;;;;;;;;;;;;;;KAgBI,aACV,qBACA,wCACiB,gBAEf,iBAAiB,qBAAoB,2BACnC,qBAAqB,eAAe,qBAClC,WACA,2BACM,eACA,SAAS;;;;;;;;;;;;;;;cAiBV,6BACL,oCACA,eAAe,gBAAgB,uBAAqB,eAE3C,eAAa,SACnB,QAAM,eACA,iBACd,oBAAoB;;;;;cAkCV,wBACL,2BACA,eAAe,eAAa,eAEnB,MAAI,QACX,WACP,aAAa,MAAM;;;;cAoBT,uBACL,2BACA,eAAe,gBAAgB,uBAAqB,UAEhD,MAAI,QACN,QAAM,UACJ"}
+{"version":3,"file":"rewriteUtils.d.ts","names":[],"sources":["../../../src/localization/rewriteUtils.ts"],"mappings":";;;;;;;;;;YAgBY,oBAAoB;EAC1B,MAAM;EAAe;;EACrB;EAAc;;;KAGf,iBAAiB,uBAAuB,4BACzC,WACI;;;;;;;;;;;;;;;YAgBI,aACV,qBACA,wCACiB,gBAEf,iBAAiB,qBAAoB,2BACnC,qBAAqB,eAAe,qBAClC,WACA,2BACM,eACA,SAAS;;;;;;;;;;;;;;;qBAiBV,6BACL,oCACA,eAAe,gBAAgB,uBAAqB,eAE3C,eAAa,SACnB,QAAM,eACA,iBACd,oBAAoB;;;;;qBAkCV,wBACL,2BACA,eAAe,eAAa,eAEnB,MAAI,QACX,WACP,aAAa,MAAM;;;;qBAoBT,uBACL,2BACA,eAAe,gBAAgB,uBAAqB,UAEhD,MAAI,QACN,QAAM,UACJ"}

package/dist/types/localization/validatePrefix.d.ts

@@ -1,7 +1,7 @@
 import { RoutingOptions } from "./getPrefix.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/localization/validatePrefix.d.ts
-type ValidatePrefixResult = {
+export type ValidatePrefixResult = {
   isValid: boolean;
   localePrefix: string | undefined;
 };
@@ -27,7 +27,6 @@ type ValidatePrefixResult = {
  *   mode: 'prefix-all',
  * });
  */
-declare const validatePrefix: (locale: LocalesValues | undefined | null, options?: RoutingOptions) => ValidatePrefixResult;
+export declare const validatePrefix: (locale: LocalesValues | undefined | null, options?: RoutingOptions) => ValidatePrefixResult;
 //#endregion
-export { ValidatePrefixResult, validatePrefix };
 //# sourceMappingURL=validatePrefix.d.ts.map

package/dist/types/localization/validatePrefix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validatePrefix.d.ts","names":[],"sources":["../../../src/localization/validatePrefix.ts"],"mappings":";;;KAyBY;EACV;EACA;;;;;;;;;;;;;;;;;;;;;;;;cAyBW,iBAAc,QACjB,kCAAgC,UAC9B,mBACT"}
+{"version":3,"file":"validatePrefix.d.ts","names":[],"sources":["../../../src/localization/validatePrefix.ts"],"mappings":";;;YAyBY;EACV;EACA;;;;;;;;;;;;;;;;;;;;;;;;qBAyBW,iBAAc,QACjB,kCAAgC,UAC9B,mBACT"}

package/dist/types/markdown/compiler.d.ts

@@ -1,15 +1,58 @@
 import { CompileOptions, MarkdownContext, MarkdownOptions, MarkdownRuntime } from "./types.js";
+import { parserFor } from "./parser.js";
+import { renderFor } from "./renderer.js";
 //#region src/markdown/compiler.d.ts
+type CreateElementFunction = (tag: any, props: Record<string, any> | null, ...children: any[]) => unknown;
 type FootnoteDef = {
   footnote: string;
   identifier: string;
 };
+/**
+ * Footnote and reference tables belonging to the document currently being
+ * parsed or rendered. Rules reach them through a ref so a rule set can outlive
+ * a single document and be reused.
+ */
+type DocumentScope = {
+  footnotes: FootnoteDef[];
+  references: MarkdownReferences;
+};
+type DocumentScopeRef = {
+  current: DocumentScope;
+};
+/**
+ * A cached rule set, together with the values it was built from. The signature
+ * holds every input that changes the shape of the rules; anything else (the
+ * markdown itself, the document scope) is free to vary between uses.
+ */
+type DocumentParser = ReturnType<typeof parserFor>;
+type DocumentEmitter = ReturnType<typeof renderFor>;
+type RuleSetCacheEntry = {
+  /** The inputs this set was built from, compared field by field on lookup. */
+  ctx: MarkdownContext<any>;
+  options: MarkdownOptions;
+  parseOnly: boolean;
+  createElement: CreateElementFunction;
+  scope: DocumentScopeRef;
+  /**
+   * Built with the rules, not per call. `parserFor` resolves precedence and
+   * fills the first-character dispatch tables, and `renderFor` walks the rule
+   * set — repeating either for every string was most of what compiling a
+   * dictionary of short strings cost.
+   */
+  parse: DocumentParser;
+  emit: DocumentEmitter;
+};
+/**
+ * Returns the rule set for these options, building it only when no cached set
+ * was made from the same inputs.
+ */
+export declare const getRuleSet: (ctx: MarkdownContext<any>, options: MarkdownOptions, parseOnly: boolean) => RuleSetCacheEntry;
 /** Link/image reference definitions (`[id]: target "title"`) collected while parsing. */
-type MarkdownReferences = Record<string, {
+export type MarkdownReferences = Record<string, {
   target: string;
   title?: string;
 }>;
-type ParsedMarkdown = {
+export type ParsedMarkdown = {
   ast: any[];
   footnotes: FootnoteDef[];
   /**
@@ -20,11 +63,10 @@ type ParsedMarkdown = {
   references: MarkdownReferences;
   inline: boolean;
 };
-declare const parseMarkdown: (markdown: string, ctx: MarkdownContext<any>, options?: MarkdownOptions) => ParsedMarkdown;
-declare const renderMarkdownAst: (parsed: ParsedMarkdown, ctx: MarkdownContext<any>, options?: MarkdownOptions) => unknown;
-declare const compile: (markdown: string, ctx: MarkdownContext<any>, options?: MarkdownOptions) => unknown;
-declare const createCompiler: (ctx: MarkdownContext<any>) => (markdown: string, options?: MarkdownOptions) => unknown;
-declare const compileWithOptions: (markdown: string, runtime: MarkdownRuntime, options?: CompileOptions<any>) => unknown;
+export declare const parseMarkdown: (markdown: string, ctx: MarkdownContext<any>, options?: MarkdownOptions) => ParsedMarkdown;
+export declare const renderMarkdownAst: (parsed: ParsedMarkdown, ctx: MarkdownContext<any>, options?: MarkdownOptions) => unknown;
+export declare const compile: (markdown: string, ctx: MarkdownContext<any>, options?: MarkdownOptions) => unknown;
+export declare const createCompiler: (ctx: MarkdownContext<any>) => (markdown: string, options?: MarkdownOptions) => unknown;
+export declare const compileWithOptions: (markdown: string, runtime: MarkdownRuntime, options?: CompileOptions<any>) => unknown;
 //#endregion
-export { MarkdownReferences, ParsedMarkdown, compile, compileWithOptions, createCompiler, parseMarkdown, renderMarkdownAst };
 //# sourceMappingURL=compiler.d.ts.map

package/dist/types/markdown/compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;KA+GK;EAAgB;EAAkB;;;KAu6B3B,qBAAqB;EAE7B;EAAgB;;KAGR;EACV;EACA,WAAW;;;;;;EAMX,YAAY;EACZ;;cAqPW,gBAAa,kBACR,KACX,sBAAoB,UAChB,oBACR;cAcU,oBAAiB,QACpB,gBAAc,KACjB,sBAAoB,UAChB;cAcE,UAAO,kBACF,KACX,sBAAoB,UAChB;cA8BE,iBAAc,KACnB,0BAAoB,kBACT,UAAY;cAGlB,qBAAkB,kBACb,SACP,iBAAe,UACf"}
+{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;;;KAgHK,yBACH,UACA,OAAO,+BACJ;KAGA;EAAgB;EAAkB;;;;;;;KA2KlC;EACH,WAAW;EACX,YAAY;;KAGT;EAAqB,SAAS;;;;;;;KAY9B,iBAAiB,kBAAkB;KACnC,kBAAkB,kBAAkB;KAEpC;;EAEH,KAAK;EACL,SAAS;EACT;EACA,eAAe;EACf,OAAO;;;;;;;EAOP,OAAO;EACP,MAAM;;;;;;qBAsCK,aAAU,KAChB,sBAAoB,SAChB,iBAAe,uBAEvB;;YA2/BS,qBAAqB;EAE7B;EAAgB;;YAGR;EACV;EACA,WAAW;;;;;;EAMX,YAAY;EACZ;;qBAsSW,gBAAa,kBACR,KACX,sBAAoB,UAChB,oBACR;qBAiBU,oBAAiB,QACpB,gBAAc,KACjB,sBAAoB,UAChB;qBAaE,UAAO,kBACF,KACX,sBAAoB,UAChB;qBA8BE,iBAAc,KACnB,0BAAoB,kBACT,UAAY;qBAGlB,qBAAkB,kBACb,SACP,iBAAe,UACf"}

package/dist/types/markdown/constants.d.ts

@@ -3,7 +3,7 @@
  * Analogous to `node.type`. Please note that the values here may change at any time,
  * so do not hard code against the value directly.
  */
-declare const RuleType: {
+export declare const RuleType: {
   readonly blockQuote: '0';
   readonly breakLine: '1';
   readonly breakThematic: '2';
@@ -44,11 +44,11 @@ declare const RuleType: {
   readonly textStrikethroughed: '32';
   readonly unorderedList: '33';
 };
-type RuleTypeValue = (typeof RuleType)[keyof typeof RuleType];
+export type RuleTypeValue = (typeof RuleType)[keyof typeof RuleType];
 /**
  * Priority levels for rule ordering.
  */
-declare const Priority: {
+export declare const Priority: {
   /** anything that must scan the tree before everything else */
   readonly MAX: 0;
   /** scans for block-level constructs */
@@ -60,136 +60,144 @@ declare const Priority: {
   /** bare text and stuff that is considered leftovers */
   readonly MIN: 4;
 };
-type PriorityValue = (typeof Priority)[keyof typeof Priority];
+export type PriorityValue = (typeof Priority)[keyof typeof Priority];
+/**
+ * Parsing scope for markdown rules.
+ * Bitmask representation for fast bitwise checking and bundle minification.
+ * - BLOCK (1): evaluated only when !state.inline && !state.simple
+ * - INLINE (2): evaluated only when state.inline || state.simple
+ * - BOTH (3): evaluated in both scopes (default)
+ */
+export declare const RuleScope: {
+  readonly BLOCK: 1;
+  readonly INLINE: 2;
+  readonly BOTH: 3;
+};
+export declare const SCOPE_BLOCK: 1;
+export declare const SCOPE_INLINE: 2;
+export declare const SCOPE_BOTH: 3;
+export type RuleScopeValue = (typeof RuleScope)[keyof typeof RuleScope] | 'block' | 'inline' | 'both';
 /**
  * Map of HTML attributes to their JSX prop equivalents.
  * Some renderers use camelCase for certain attributes.
  */
-declare const ATTRIBUTE_TO_NODE_PROP_MAP: Record<string, string>;
+export declare const ATTRIBUTE_TO_NODE_PROP_MAP: Record<string, string>;
 /**
  * Default HTML entity to unicode mappings.
  */
-declare const NAMED_CODES_TO_UNICODE: Record<string, string>;
+export declare const NAMED_CODES_TO_UNICODE: Record<string, string>;
 /** HTML elements that should not have their content processed */
-declare const DO_NOT_PROCESS_HTML_ELEMENTS: string[];
+export declare const DO_NOT_PROCESS_HTML_ELEMENTS: string[];
 /** Attributes that require URL sanitization */
-declare const ATTRIBUTES_TO_SANITIZE: string[];
+export declare const ATTRIBUTES_TO_SANITIZE: string[];
 /** Attribute extractor regex */
-declare const ATTR_EXTRACTOR_R: RegExp;
+export declare const ATTR_EXTRACTOR_R: RegExp;
 /** Block end detection */
-declare const BLOCK_END_R: RegExp;
+export declare const BLOCK_END_R: RegExp;
 /** Blockquote patterns */
-declare const BLOCKQUOTE_R: RegExp;
-declare const BLOCKQUOTE_TRIM_LEFT_MULTILINE_R: RegExp;
-declare const BLOCKQUOTE_ALERT_R: RegExp;
+export declare const BLOCKQUOTE_R: RegExp;
+export declare const BLOCKQUOTE_TRIM_LEFT_MULTILINE_R: RegExp;
+export declare const BLOCKQUOTE_ALERT_R: RegExp;
 /** Line break patterns */
-declare const BREAK_LINE_R: RegExp;
-declare const BREAK_THEMATIC_R: RegExp;
+export declare const BREAK_LINE_R: RegExp;
+export declare const BREAK_THEMATIC_R: RegExp;
 /** Code block patterns */
-declare const CODE_BLOCK_FENCED_R: RegExp;
-declare const CODE_BLOCK_R: RegExp;
+export declare const CODE_BLOCK_FENCED_R: RegExp;
+export declare const CODE_BLOCK_R: RegExp;
 /** A single line opening or closing a fenced code block, with its indentation. */
-declare const FENCE_DELIMITER_R: RegExp;
-declare const CODE_INLINE_R: RegExp;
+export declare const FENCE_DELIMITER_R: RegExp;
+export declare const CODE_INLINE_R: RegExp;
 /** Newline patterns */
-declare const CONSECUTIVE_NEWLINE_R: RegExp;
-declare const CR_NEWLINE_R: RegExp;
+export declare const CONSECUTIVE_NEWLINE_R: RegExp;
+export declare const CR_NEWLINE_R: RegExp;
 /** Footnote patterns */
-declare const FOOTNOTE_R: RegExp;
-declare const FOOTNOTE_REFERENCE_R: RegExp;
+export declare const FOOTNOTE_R: RegExp;
+export declare const FOOTNOTE_REFERENCE_R: RegExp;
 /** Form feed */
-declare const FORMFEED_R: RegExp;
+export declare const FORMFEED_R: RegExp;
 /** Front matter */
-declare const FRONT_MATTER_R: RegExp;
+export declare const FRONT_MATTER_R: RegExp;
 /** GFM task */
-declare const GFM_TASK_R: RegExp;
+export declare const GFM_TASK_R: RegExp;
 /** Heading patterns */
-declare const HEADING_R: RegExp;
-declare const HEADING_ATX_COMPLIANT_R: RegExp;
-declare const HEADING_SETEXT_R: RegExp;
-declare const HTML_BLOCK_ELEMENT_R: RegExp;
-declare const HTML_CHAR_CODE_R: RegExp;
-declare const HTML_COMMENT_R: RegExp;
-declare const HTML_CUSTOM_ATTR_R: RegExp;
-declare const HTML_SELF_CLOSING_ELEMENT_R: RegExp;
-/** Custom component pattern */
-declare const CUSTOM_COMPONENT_R: RegExp;
+export declare const HEADING_R: RegExp;
+export declare const HEADING_ATX_COMPLIANT_R: RegExp;
+export declare const HEADING_SETEXT_R: RegExp;
+/** HTML patterns */
+export declare const HTML_CHAR_CODE_R: RegExp;
+export declare const HTML_COMMENT_R: RegExp;
+export declare const HTML_CUSTOM_ATTR_R: RegExp;
 /** Interpolation */
-declare const INTERPOLATION_R: RegExp;
+export declare const INTERPOLATION_R: RegExp;
 /** Link patterns */
-declare const LINK_AUTOLINK_BARE_URL_R: RegExp;
-declare const LINK_AUTOLINK_R: RegExp;
-declare const CAPTURE_LETTER_AFTER_HYPHEN: RegExp;
-/** Table patterns */
-declare const NP_TABLE_R: RegExp;
-declare const TABLE_TRIM_PIPES: RegExp;
-declare const TABLE_CENTER_ALIGN: RegExp;
-declare const TABLE_LEFT_ALIGN: RegExp;
-declare const TABLE_RIGHT_ALIGN: RegExp;
-/** Paragraph */
-declare const PARAGRAPH_R: RegExp;
-/** Reference patterns */
-declare const REFERENCE_IMAGE_OR_LINK: RegExp;
-declare const REFERENCE_IMAGE_R: RegExp;
-declare const REFERENCE_LINK_R: RegExp;
+export declare const LINK_AUTOLINK_BARE_URL_R: RegExp;
+export declare const LINK_AUTOLINK_R: RegExp;
+export declare const CAPTURE_LETTER_AFTER_HYPHEN: RegExp;
 /**
- * Cheap prefix probes used to reject a rule before its full (and far more
- * expensive) block regex runs. Kept as module constants so the parser's inner
- * loop never allocates a `RegExp` per candidate position.
+ * Table patterns.
+ *
+ * The row scans spell "any character but a newline" as `[^\n]` rather than `.`:
+ * `.` is a four-range exclusion, and matching it over rows this wide costs a
+ * third more than the single-range class. It is also the more faithful reading
+ * — only `\n` ends a line here, and `\r` is normalized away before parsing.
  */
-declare const HTML_BLOCK_OPENING_TAG_R: RegExp;
-declare const HTML_SELF_CLOSING_OPENING_TAG_R: RegExp;
-declare const CUSTOM_COMPONENT_OPENING_TAG_R: RegExp;
+export declare const NP_TABLE_R: RegExp;
+export declare const TABLE_TRIM_PIPES: RegExp;
+export declare const TABLE_CENTER_ALIGN: RegExp;
+export declare const TABLE_LEFT_ALIGN: RegExp;
+export declare const TABLE_RIGHT_ALIGN: RegExp;
+/** Paragraph */
+export declare const PARAGRAPH_R: RegExp;
+/** Reference patterns */
+export declare const REFERENCE_IMAGE_OR_LINK: RegExp;
+export declare const REFERENCE_IMAGE_R: RegExp;
+export declare const REFERENCE_LINK_R: RegExp;
 /** Block detection */
-declare const SHOULD_RENDER_AS_BLOCK_R: RegExp;
-/** Tab and whitespace */
-declare const TAB_R: RegExp;
-/** Every character `normalizeWhitespace` rewrites, so it needs a single pass. */
-declare const NORMALIZE_WHITESPACE_R: RegExp;
-declare const TRIM_STARTING_NEWLINES: RegExp;
-declare const HTML_LEFT_TRIM_AMOUNT_R: RegExp;
+export declare const SHOULD_RENDER_AS_BLOCK_R: RegExp;
+/** Tabs, which `normalizeWhitespace` widens to four spaces. */
+export declare const TAB_R: RegExp;
+export declare const TRIM_STARTING_NEWLINES: RegExp;
+export declare const HTML_LEFT_TRIM_AMOUNT_R: RegExp;
 /** List patterns */
-declare const ORDERED_LIST_BULLET = "(?:\\d+\\.)";
-declare const UNORDERED_LIST_BULLET = "(?:[*+-])";
+export declare const ORDERED_LIST_BULLET = "(?:\\d+\\.)";
+export declare const UNORDERED_LIST_BULLET = "(?:[*+-])";
 /** Text formatting patterns */
-declare const TEXT_ESCAPED_R: RegExp;
-declare const UNESCAPE_R: RegExp;
-declare const TEXT_PLAIN_R: RegExp;
+export declare const TEXT_ESCAPED_R: RegExp;
+export declare const UNESCAPE_R: RegExp;
 /** Shortcode pattern */
-declare const SHORTCODE_R: RegExp;
-type ListType = 1 | 2;
-declare const ORDERED: ListType;
-declare const UNORDERED: ListType;
+export declare const SHORTCODE_R: RegExp;
+export type ListType = 1 | 2;
+export declare const ORDERED: ListType;
+export declare const UNORDERED: ListType;
 /**
  * Ensure there's at least one more instance of the delimiter later
  * in the current sequence.
  */
-declare const LOOKAHEAD: (double: number) => string;
+export declare const LOOKAHEAD: (double: number) => string;
 /**
  * For inline formatting, this partial attempts to ignore characters that
  * may appear in nested formatting.
  */
-declare const INLINE_SKIP_R = "((?:\\[.*?\\][([].*?[)\\]]|<.*?>(?:.*?<.*?>)?|`.*?`|\\\\[^\\s]|[\\s\\S])+?)";
+export declare const INLINE_SKIP_R = "((?:\\[.*?\\][([].*?[)\\]]|<.*?>(?:.*?<.*?>)?|`.*?`|\\\\[^\\s]|[\\s\\S])+?)";
 /** Bold text pattern */
-declare const TEXT_BOLD_R: RegExp;
+export declare const TEXT_BOLD_R: RegExp;
 /** Emphasized text pattern */
-declare const TEXT_EMPHASIZED_R: RegExp;
+export declare const TEXT_EMPHASIZED_R: RegExp;
 /** Marked text pattern */
-declare const TEXT_MARKED_R: RegExp;
+export declare const TEXT_MARKED_R: RegExp;
 /** Strikethrough text pattern */
-declare const TEXT_STRIKETHROUGHED_R: RegExp;
-declare const generateListItemPrefix: (type: ListType) => string;
-declare const ORDERED_LIST_ITEM_PREFIX: string;
-declare const UNORDERED_LIST_ITEM_PREFIX: string;
-declare const generateListItemPrefixRegex: (type: ListType) => RegExp;
-declare const ORDERED_LIST_ITEM_PREFIX_R: RegExp;
-declare const UNORDERED_LIST_ITEM_PREFIX_R: RegExp;
-declare const generateListItemRegex: (type: ListType) => RegExp;
-declare const ORDERED_LIST_ITEM_R: RegExp;
-declare const UNORDERED_LIST_ITEM_R: RegExp;
-declare const generateListRegex: (type: ListType) => RegExp;
-declare const ORDERED_LIST_R: RegExp;
-declare const UNORDERED_LIST_R: RegExp;
+export declare const TEXT_STRIKETHROUGHED_R: RegExp;
+export declare const generateListItemPrefix: (type: ListType) => string;
+export declare const ORDERED_LIST_ITEM_PREFIX: string;
+export declare const UNORDERED_LIST_ITEM_PREFIX: string;
+export declare const generateListItemPrefixRegex: (type: ListType) => RegExp;
+export declare const ORDERED_LIST_ITEM_PREFIX_R: RegExp;
+export declare const UNORDERED_LIST_ITEM_PREFIX_R: RegExp;
+export declare const generateListItemRegex: (type: ListType) => RegExp;
+export declare const ORDERED_LIST_ITEM_R: RegExp;
+export declare const UNORDERED_LIST_ITEM_R: RegExp;
+export declare const generateListRegex: (type: ListType) => RegExp;
+export declare const ORDERED_LIST_R: RegExp;
+export declare const UNORDERED_LIST_R: RegExp;
 //#endregion
-export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_OPENING_TAG_R, CUSTOM_COMPONENT_R, DO_NOT_PROCESS_HTML_ELEMENTS, FENCE_DELIMITER_R, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTML_BLOCK_ELEMENT_R, HTML_BLOCK_OPENING_TAG_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_SELF_CLOSING_OPENING_TAG_R, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LOOKAHEAD, ListType, NAMED_CODES_TO_UNICODE, NORMALIZE_WHITESPACE_R, NP_TABLE_R, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, PARAGRAPH_R, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, RuleTypeValue, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex };
 //# sourceMappingURL=constants.d.ts.map

package/dist/types/markdown/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/markdown/constants.ts"],"mappings":";;;;;cAQa;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;WACA;;WAEA;;WAEA;WACA;WACA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;KAUU,wBAAwB,uBAAuB;;;;cAS9C;;WAEX;;WAEA;;WAEA;;WAEA;;WAEA;;KAGU,wBAAwB,uBAAuB;;;;;cAU9C,4BAA4B;;;;cAuD5B,wBAAwB;;cAcxB;;cAGA;;cAcA,kBAAgB;;cAIhB,aAAW;;cAGX,cAAY;cACZ,kCAAgC;cAChC,oBAAkB;;cAGlB,cAAY;cACZ,kBAAgB;;cAGhB,qBAAmB;cAEnB,cAAY;;cAEZ,mBAAiB;cACjB,eAAa;;cAGb,uBAAqB;cACrB,cAAY;;cAGZ,YAAU;cACV,sBAAoB;;cAGpB,YAAU;;cAGV,gBAAc;;cAGd,YAAU;;cAGV,WAAS;cACT,yBAAuB;cAEvB,kBAAgB;cAqChB,sBAAoB;cAIpB,kBAAgB;cAEhB,gBAAc;cACd,oBAAkB;cAClB,6BAA2B;;cAM3B,oBAAkB;;cAKlB,iBAAe;;cAGf,0BAAwB;cACxB,iBAAe;cACf,6BAA2B;;cAG3B,YAAU;cAEV,kBAAgB;cAChB,oBAAkB;cAClB,kBAAgB;cAChB,mBAAiB;;cAGjB,aAAW;;cAGX,yBAAuB;cAEvB,mBAAiB;cACjB,kBAAgB;;;;;;cAOhB,0BAAwB;cACxB,iCAA+B;cAE/B,gCAA8B;;cAG9B,0BAAwB;;cAGxB,OAAK;;cAEL,wBAAsB;cACtB,wBAAsB;cACtB,yBAAuB;;cAGvB;cACA;;cAGA,gBAAc;cACd,YAAU;cACV,cAAY;;cAIZ,aAAW;KAMZ;cACC,SAAS;cACT,WAAW;;;;;cAUX,YAAS;;;;;cAOT;;cAIA,aAAW;;cAKX,mBAAiB;;cAKjB,eAAa;;cAKb,wBAAsB;cAQtB,yBAAsB,MAAU;cAQhC;cACA;cAEA,8BAA2B,MAAU,aAAW;cAOhD,4BAA0B;cAC1B,8BAA4B;cAG5B,wBAAqB,MAAU,aAAW;cAc1C,qBAAmB;cACnB,uBAAqB;cAErB,oBAAiB,MAAU,aAAW;cAiBtC,gBAAc;cACd,kBAAgB"}
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/markdown/constants.ts"],"mappings":";;;;;qBAQa;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;WACA;;WAEA;;WAEA;WACA;WACA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;YAUU,wBAAwB,uBAAuB;;;;qBAS9C;;WAEX;;WAEA;;WAEA;;WAEA;;WAEA;;YAGU,wBAAwB,uBAAuB;;;;;;;;qBAa9C;WACX;WACA;WACA;;qBAGW;qBACA;qBACA;YAED,yBACA,wBAAwB;;;;;qBAavB,4BAA4B;;;;qBAuD5B,wBAAwB;;qBAcxB;;qBAGA;;qBAcA,kBAAgB;;qBAIhB,aAAW;;qBAGX,cAAY;qBACZ,kCAAgC;qBAChC,oBAAkB;;qBAGlB,cAAY;qBACZ,kBAAgB;;qBAOhB,qBAAmB;qBAEnB,cAAY;;qBAEZ,mBAAiB;qBACjB,eAAa;;qBAGb,uBAAqB;qBACrB,cAAY;;qBAGZ,YAAU;qBACV,sBAAoB;;qBAGpB,YAAU;;qBAGV,gBAAc;;qBAGd,YAAU;;qBAGV,WAAS;qBACT,yBAAuB;qBAEvB,kBAAgB;;qBAIhB,kBAAgB;qBAEhB,gBAAc;qBACd,oBAAkB;;qBAGlB,iBAAe;;qBAGf,0BAAwB;qBACxB,iBAAe;qBACf,6BAA2B;;;;;;;;;qBAU3B,YAAU;qBAEV,kBAAgB;qBAChB,oBAAkB;qBAClB,kBAAgB;qBAChB,mBAAiB;;qBAGjB,aAAW;;qBAGX,yBAAuB;qBAEvB,mBAAiB;qBACjB,kBAAgB;;qBAGhB,0BAAwB;;qBAGxB,OAAK;qBACL,wBAAsB;qBACtB,yBAAuB;;qBAGvB;qBACA;;qBAGA,gBAAc;qBACd,YAAU;;qBAGV,aAAW;YAMZ;qBACC,SAAS;qBACT,WAAW;;;;;qBAUX,YAAS;;;;;qBAOT;;qBAIA,aAAW;;qBAKX,mBAAiB;;qBAKjB,eAAa;;qBAKb,wBAAsB;qBAQtB,yBAAsB,MAAU;qBAQhC;qBACA;qBAEA,8BAA2B,MAAU,aAAW;qBAOhD,4BAA0B;qBAC1B,8BAA4B;qBAG5B,wBAAqB,MAAU,aAAW;qBAc1C,qBAAmB;qBACnB,uBAAqB;qBAErB,oBAAiB,MAAU,aAAW;qBA4BtC,gBAAc;qBACd,kBAAgB"}

package/dist/types/markdown/elementScanner.d.ts

@@ -0,0 +1,14 @@
+//#region src/markdown/elementScanner.d.ts
+/**
+ * Lean, non-backtracking element scanner for HTML blocks, custom components, and self-closing tags.
+ */
+export declare const matchElement: (source: string, customComponent: boolean) => RegExpMatchArray | null;
+export declare const matchSelfClosingElement: (source: string) => RegExpMatchArray | null;
+export declare const matchHtmlBlockElement: (source: string) => RegExpMatchArray;
+export declare const matchCustomComponent: (source: string) => RegExpMatchArray;
+export declare const startsWithHtmlBlockElement: (source: string) => boolean;
+export declare const startsWithSelfClosingElement: (source: string) => boolean;
+export declare const startsWithCustomComponent: (source: string) => boolean;
+export declare const startsWithElement: (source: string) => boolean;
+//#endregion
+//# sourceMappingURL=elementScanner.d.ts.map

package/dist/types/markdown/elementScanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementScanner.d.ts","names":[],"sources":["../../../src/markdown/elementScanner.ts"],"mappings":";;;;qBA+Ga,eAAY,gBACT,6BAEb;qBAkHU,0BAAuB,mBAEjC;qBA4DU,wBAAqB,mBAAkB;qBAEvC,uBAAoB,mBAAkB;qBAEtC,6BAA0B;qBAE1B,+BAA4B;qBAE5B,4BAAyB;qBAEzB,oBAAiB"}

package/dist/types/markdown/index.d.ts

@@ -3,10 +3,10 @@ import { getMarkdownMetadata } from "../transpiler/markdown/getMarkdownMetadata.
 import { MarkdownContent, MarkdownContentConstructor, md as markdown } from "../transpiler/markdown/markdown.js";
 import { MarkdownValidationResult, validateMarkdown } from "../transpiler/markdown/validateMarkdown.js";
 import "../transpiler/markdown/index.js";
+import { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, DO_NOT_PROCESS_HTML_ELEMENTS, FENCE_DELIMITER_R, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LOOKAHEAD, ListType, NAMED_CODES_TO_UNICODE, NP_TABLE_R, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, PARAGRAPH_R, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleScope, RuleScopeValue, RuleType, RuleTypeValue, SCOPE_BLOCK, SCOPE_BOTH, SCOPE_INLINE, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex } from "./constants.js";
 import { BlockQuoteNode, BoldTextNode, BreakLineNode, BreakThematicNode, CodeBlockNode, CodeFencedNode, CodeInlineNode, CompileOptions, ComponentOverrides, CustomComponentNode, ElementType, EscapedTextNode, FootnoteNode, FootnoteReferenceNode, GFMTaskNode, HTMLCommentNode, HTMLNode, HTMLSelfClosingNode, HTMLTag, HeadingNode, HeadingSetextNode, ImageNode, ItalicTextNode, LinkAngleBraceNode, LinkBareURLNode, LinkNode, MarkdownContext, MarkdownOptions, MarkdownRuntime, MarkedTextNode, NestedParser, NewlineNode, OrderedListNode, ParagraphNode, ParseState, Parser, ParserResult, ReferenceImageNode, ReferenceLinkNode, ReferenceNode, RenderRuleHook, Rule, RuleOutput, Rules, StrikethroughTextNode, TableNode, TableSeparatorNode, TextNode, UnorderedListNode } from "./types.js";
-import { MarkdownReferences, ParsedMarkdown, compile, compileWithOptions, createCompiler, parseMarkdown, renderMarkdownAst } from "./compiler.js";
-import { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_OPENING_TAG_R, CUSTOM_COMPONENT_R, DO_NOT_PROCESS_HTML_ELEMENTS, FENCE_DELIMITER_R, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTML_BLOCK_ELEMENT_R, HTML_BLOCK_OPENING_TAG_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_SELF_CLOSING_OPENING_TAG_R, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LOOKAHEAD, ListType, NAMED_CODES_TO_UNICODE, NORMALIZE_WHITESPACE_R, NP_TABLE_R, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, PARAGRAPH_R, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, RuleTypeValue, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex } from "./constants.js";
 import { parserFor } from "./parser.js";
 import { createRenderer, renderFor } from "./renderer.js";
-import { allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, cx, get, inlineRegex, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, qualifies, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote } from "./utils.js";
-export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, type BlockQuoteNode, type BoldTextNode, type BreakLineNode, type BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_OPENING_TAG_R, CUSTOM_COMPONENT_R, type CodeBlockNode, type CodeFencedNode, type CodeInlineNode, type CompileOptions, type ComponentOverrides, type CustomComponentNode, DO_NOT_PROCESS_HTML_ELEMENTS, type ElementType, type EscapedTextNode, FENCE_DELIMITER_R, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, type HTMLCommentNode, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, HTML_BLOCK_ELEMENT_R, HTML_BLOCK_OPENING_TAG_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_SELF_CLOSING_OPENING_TAG_R, type HeadingNode, type HeadingSetextNode, INLINE_SKIP_R, INTERPOLATION_R, type ImageNode, type ItalicTextNode, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LOOKAHEAD, type LinkAngleBraceNode, type LinkBareURLNode, type LinkNode, ListType, MarkdownContent, MarkdownContentConstructor, type MarkdownContext, type MarkdownOptions, MarkdownReferences, type MarkdownRuntime, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, type MarkedTextNode, NAMED_CODES_TO_UNICODE, NORMALIZE_WHITESPACE_R, NP_TABLE_R, type NestedParser, type NewlineNode, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, type OrderedListNode, PARAGRAPH_R, type ParagraphNode, type ParseState, ParsedMarkdown, type Parser, type ParserResult, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, type Rule, type RuleOutput, RuleType, RuleTypeValue, type Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, type StrikethroughTextNode, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, type TableNode, type TableSeparatorNode, type TextNode, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, type UnorderedListNode, allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, compile, compileWithOptions, createCompiler, createRenderer, cx, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, get, getMarkdownMetadata, inlineRegex, markdown as md, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parserFor, qualifies, renderFor, renderMarkdownAst, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote, validateMarkdown };
+import { MarkdownReferences, ParsedMarkdown, compile, compileWithOptions, createCompiler, getRuleSet, parseMarkdown, renderMarkdownAst } from "./compiler.js";
+import { BlockSyntaxProbe, allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, cx, get, inlineRegex, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, qualifies, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote } from "./utils.js";
+export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, type BlockQuoteNode, BlockSyntaxProbe, type BoldTextNode, type BreakLineNode, type BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, type CodeBlockNode, type CodeFencedNode, type CodeInlineNode, type CompileOptions, type ComponentOverrides, type CustomComponentNode, DO_NOT_PROCESS_HTML_ELEMENTS, type ElementType, type EscapedTextNode, FENCE_DELIMITER_R, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, type HTMLCommentNode, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, type HeadingNode, type HeadingSetextNode, INLINE_SKIP_R, INTERPOLATION_R, type ImageNode, type ItalicTextNode, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LOOKAHEAD, type LinkAngleBraceNode, type LinkBareURLNode, type LinkNode, ListType, MarkdownContent, MarkdownContentConstructor, type MarkdownContext, type MarkdownOptions, MarkdownReferences, type MarkdownRuntime, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, type MarkedTextNode, NAMED_CODES_TO_UNICODE, NP_TABLE_R, type NestedParser, type NewlineNode, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, type OrderedListNode, PARAGRAPH_R, type ParagraphNode, type ParseState, ParsedMarkdown, type Parser, type ParserResult, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, type Rule, type RuleOutput, RuleScope, RuleScopeValue, RuleType, RuleTypeValue, type Rules, SCOPE_BLOCK, SCOPE_BOTH, SCOPE_INLINE, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, type StrikethroughTextNode, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, type TableNode, type TableSeparatorNode, type TextNode, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, type UnorderedListNode, allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, compile, compileWithOptions, createCompiler, createRenderer, cx, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, get, getMarkdownMetadata, getRuleSet, inlineRegex, markdown as md, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parserFor, qualifies, renderFor, renderMarkdownAst, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote, validateMarkdown };

package/dist/types/markdown/parser.d.ts

@@ -3,13 +3,7 @@ import { ParseState, ParserResult, Rules } from "./types.js";
 /**
  * Creates a parser for a given set of rules, with the precedence
  * specified as a list of rules.
- *
- * @param rules - An object containing rule type -> {match, order, parse} objects
- *                (lower order is higher precedence)
- *
- * @returns The resulting parse function
  */
-declare const parserFor: (rules: Rules) => ((source: string, state: ParseState) => ParserResult[]);
+export declare const parserFor: (rules: Rules) => ((source: string, state: ParseState) => ParserResult[]);
 //#endregion
-export { parserFor };
 //# sourceMappingURL=parser.d.ts.map

package/dist/types/markdown/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/markdown/parser.ts"],"mappings":";;;;;;;;;;;cAoHa,YAAS,OACb,YACJ,gBAAgB,OAAO,eAAe"}
+{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/markdown/parser.ts"],"mappings":";;;;;;qBAoEa,YAAS,OACb,YACJ,gBAAgB,OAAO,eAAe"}

package/dist/types/markdown/renderer.d.ts

@@ -7,15 +7,10 @@ import { ParseState, ParserResult, RenderRuleHook, RuleOutput, Rules } from "./t
  * @param render - The render function to call for each node
  * @returns A function that renders AST to output
  */
-declare const renderFor: (render: (ast: ParserResult, render: RuleOutput, state: ParseState) => unknown) => (ast: ParserResult | ParserResult[], state?: ParseState) => any;
+export declare const renderFor: (render: (ast: ParserResult, render: RuleOutput, state: ParseState) => unknown) => (ast: ParserResult | ParserResult[], state?: ParseState) => any;
 /**
  * Creates a renderer from rules with optional custom render hook.
- *
- * @param rules - The rules object containing _render functions
- * @param userRender - Optional custom render hook for full control
- * @returns A render function for AST nodes
  */
-declare const createRenderer: (rules: Rules, userRender?: RenderRuleHook) => (ast: ParserResult, render: RuleOutput, state: ParseState) => unknown;
+export declare const createRenderer: (rules: Rules, userRender?: RenderRuleHook) => (ast: ParserResult, render: RuleOutput, state: ParseState) => unknown;
 //#endregion
-export { createRenderer, renderFor };
 //# sourceMappingURL=renderer.d.ts.map

package/dist/types/markdown/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","names":[],"sources":["../../../src/markdown/renderer.ts"],"mappings":";;;;;;;;;cAea,YAAS,SACX,KAAK,cAAc,QAAQ,YAAY,OAAO,4BAAsB,KAKtE,eAAe,gBAAc,QAC3B;;;;;;;;cA8CE,iBAAc,OACjB,OAAK,aAAe,oBAAc,KACpC,cAAY,QAAU,YAAU,OAAS"}
+{"version":3,"file":"renderer.d.ts","names":[],"sources":["../../../src/markdown/renderer.ts"],"mappings":";;;;;;;;;qBAiBa,YAAS,SACX,KAAK,cAAc,QAAQ,YAAY,OAAO,4BAAsB,KAGtE,eAAe,gBAAc,QAC3B;;;;qBA0CE,iBAAc,OAAW,OAAK,aAAe,oBAAc,KAM7D,cAAY,QACT,YAAU,OACX"}