@intlayer/core 9.4.1 → 9.4.2

package/dist/esm/localization/rewriteUtils.mjs

@@ -1,69 +1,9 @@
+import { extractParams, fillPath, getRewriteRules } from "./rewriteMatch.mjs";
+import { getCanonicalPath } from "./getCanonicalPath.mjs";
 import { internationalization } from "@intlayer/config/built";
 
 //#region src/localization/rewriteUtils.ts
 /**
-* Normalizes legacy Record format or extracts specialized rules from RewriteObject.
-*
-* Idempotent: already-normalized rules are handed back untouched, so a caller
-* holding resolved rules can pass them on without re-normalizing.
-*/
-const getRewriteRules = (rewrite, context = "url") => {
-	if (!rewrite || process.env.INTLAYER_ROUTING_REWRITE_RULES && process.env.INTLAYER_ROUTING_REWRITE_RULES === "false") return void 0;
-	if (Array.isArray(rewrite.rules)) return rewrite;
-	if ("url" in rewrite) return rewrite[context];
-	return { rules: Object.entries(rewrite).map(([canonical, localized]) => ({
-		canonical: canonical.startsWith("/") ? canonical.replace(/\[([^\]]+)\]/g, ":$1") : `/${canonical.replace(/\[([^\]]+)\]/g, ":$1")}`,
-		localized: Object.fromEntries(Object.entries(localized).map(([locale, pattern]) => {
-			return [locale, pattern?.startsWith("/") ? pattern.replace(/\[([^\]]+)\]/g, ":$1") : `/${(pattern || "").replace(/\[([^\]]+)\]/g, ":$1")}`];
-		}))
-	})) };
-};
-/**
-* Converts normalized pattern to Regex.
-* Internal syntax supports:
-* - :param -> ([^/]+) (one segment)
-* - :param* -> (.*) (zero or more segments)
-* - :param+ -> (.+) (one or more segments)
-* - :param? -> ([^/]*) (zero or one segment)
-*/
-const patternToRegex = (pattern) => {
-	const regexString = pattern.replace(/\//g, "\\/").replace(/\\\/:(?:[^/\\*+?]+)\*/g, "(?:\\/(.*))?").replace(/\\\/:(?:[^/\\*+?]+)\?/g, "(?:\\/([^\\/]+))?").replace(/:([^/\\*+?]+)\*/g, "(.*)").replace(/:([^/\\*+?]+)\?/g, "([^\\/]*)").replace(/:([^/\\*+?]+)\+/g, "(.+)").replace(/:([^/\\*+?]+)/g, "([^\\/]+)");
-	return new RegExp(`^${regexString}$`);
-};
-/**
-* Replaces route parameters in a path with provided values.
-*/
-const fillPath = (pattern, params) => {
-	let index = 0;
-	return pattern.replace(/:([^/\\*+?]+)[*+?]?/g, () => params[index++] ?? "").replace(/\/+/g, "/").replace(/\/$/, "") || "/";
-};
-/**
-* Extract values from a URL based on a pattern.
-*/
-const extractParams = (url, pattern) => {
-	const regex = patternToRegex(pattern);
-	const match = url.match(regex);
-	return match ? match.slice(1) : null;
-};
-/**
-* Given a localized URL (e.g., "/produits/123"), finds the canonical internal path (e.g., "/products/123").
-* If locale is provided, only check for that locale. Otherwise, check for all locales.
-*/
-const getCanonicalPath = (localizedPath, locale, rewriteRules) => {
-	if (!rewriteRules || process.env.INTLAYER_ROUTING_REWRITE_RULES && process.env.INTLAYER_ROUTING_REWRITE_RULES === "false") return localizedPath;
-	for (const rule of rewriteRules.rules) {
-		const { canonical, localized } = rule;
-		const localesToCheck = locale ? [locale] : Object.keys(localized);
-		for (const loc of localesToCheck) {
-			const localizedPattern = localized[loc];
-			if (!localizedPattern) continue;
-			const params = extractParams(localizedPath, localizedPattern);
-			if (params) return fillPath(canonical, params);
-		}
-	}
-	return localizedPath;
-};
-/**
 * Given a canonical path (e.g., "/products/123"), finds the localized URL pattern
 * (e.g., "/produits/123") and reports whether a rule actually matched.
 *
@@ -120,5 +60,5 @@ const getRewritePath = (pathname, locale, rewrite) => {
 };
 
 //#endregion
-export { getCanonicalPath, getInternalPath, getRewritePath, getRewriteRules, resolveLocalizedPath };
+export { getInternalPath, getRewritePath, resolveLocalizedPath };
 //# sourceMappingURL=rewriteUtils.mjs.map

package/dist/esm/localization/rewriteUtils.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rewriteUtils.mjs","names":["legacyRules"],"sources":["../../../src/localization/rewriteUtils.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type {\n  RewriteObject,\n  RewriteRules,\n  RoutingConfig,\n} from '@intlayer/types/config';\nimport type {\n  LocalesValues,\n  ResolvedDefaultLocale,\n} from '@intlayer/types/module_augmentation';\n\n/**\n * Outcome of resolving a canonical path against the rewrite rules.\n *\n * Discriminated on `isRewritten`: when no rule matched, `path` is the very\n * input that was passed in, so a literal input keeps its literal type. Only a\n * rewritten path is computed at runtime and therefore widens to `string`.\n */\nexport type LocalizedPathResult<CanonicalPath extends string = string> =\n  | { path: CanonicalPath; isRewritten: false }\n  | { path: string; isRewritten: true };\n\n/** Adds the leading slash a path may be missing. */\ntype WithLeadingSlash<Path extends string> = Path extends `/${string}`\n  ? Path\n  : `/${Path}`;\n\n/**\n * Computes the locale-prefixed internal path for a path and a locale, mirroring\n * `getInternalPath`'s runtime behaviour: an already-prefixed path is returned\n * untouched, the root collapses to `/${Locale}` (never a trailing slash), and\n * anything else gets the prefix prepended.\n *\n * Falls back to `string` for a non-literal path, where the prefixed and\n * already-prefixed cases cannot be told apart.\n *\n * @example\n * type A = InternalPath<'/about', 'fr'>;    // '/fr/about'\n * type B = InternalPath<'/', 'fr'>;         // '/fr'\n * type C = InternalPath<'/fr/about', 'fr'>; // '/fr/about' (already prefixed)\n */\nexport type InternalPath<\n  Path extends string,\n  Locale extends string,\n> = string extends Path\n  ? string\n  : WithLeadingSlash<Path> extends infer Prefixed extends string\n    ? Prefixed extends `/${Locale}` | `/${Locale}/${string}`\n      ? Prefixed\n      : Prefixed extends '/'\n        ? `/${Locale}`\n        : `/${Locale}${Prefixed}`\n    : never;\n\n/**\n * Normalizes legacy Record format or extracts specialized rules from RewriteObject.\n *\n * Idempotent: already-normalized rules are handed back untouched, so a caller\n * holding resolved rules can pass them on without re-normalizing.\n */\nexport const getRewriteRules = <\n  const Context extends keyof RewriteObject = 'url',\n>(\n  rewrite: RoutingConfig['rewrite'] | RewriteRules,\n  context: Context = 'url' as Context\n): RewriteRules | undefined => {\n  if (\n    !rewrite ||\n    (process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n      process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false')\n  )\n    return undefined;\n\n  if (Array.isArray((rewrite as RewriteRules).rules)) {\n    return rewrite as RewriteRules;\n  }\n\n  if ('url' in rewrite) {\n    return (rewrite as RewriteObject)[context];\n  }\n\n  // Normalize legacy format\n  const legacyRules = rewrite as Record<string, Record<string, string>>;\n\n  return {\n    rules: Object.entries(legacyRules).map(([canonical, localized]) => ({\n      // Normalize canonical path\n      canonical: canonical.startsWith('/')\n        ? canonical.replace(/\\[([^\\]]+)\\]/g, ':$1')\n        : `/${canonical.replace(/\\[([^\\]]+)\\]/g, ':$1')}`,\n\n      // Normalize localized path\n      localized: Object.fromEntries(\n        Object.entries(localized).map(([locale, pattern]) => {\n          const normalizedPattern = pattern?.startsWith('/')\n            ? pattern.replace(/\\[([^\\]]+)\\]/g, ':$1')\n            : `/${(pattern || '').replace(/\\[([^\\]]+)\\]/g, ':$1')}`;\n          return [locale, normalizedPattern];\n        })\n      ),\n    })),\n  };\n};\n\n/**\n * Converts normalized pattern to Regex.\n * Internal syntax supports:\n * - :param -> ([^/]+) (one segment)\n * - :param* -> (.*) (zero or more segments)\n * - :param+ -> (.+) (one or more segments)\n * - :param? -> ([^/]*) (zero or one segment)\n */\nconst patternToRegex = (pattern: string) => {\n  const regexString = pattern\n    .replace(/\\//g, '\\\\/') // Escape slashes\n    .replace(/\\\\\\/:(?:[^/\\\\*+?]+)\\*/g, '(?:\\\\/(.*))?') // /:param*\n    .replace(/\\\\\\/:(?:[^/\\\\*+?]+)\\?/g, '(?:\\\\/([^\\\\/]+))?') // /:param?\n    .replace(/:([^/\\\\*+?]+)\\*/g, '(.*)') // :param* (if no leading slash)\n    .replace(/:([^/\\\\*+?]+)\\?/g, '([^\\\\/]*)') // :param? (if no leading slash)\n    .replace(/:([^/\\\\*+?]+)\\+/g, '(.+)') // :param+\n    .replace(/:([^/\\\\*+?]+)/g, '([^\\\\/]+)'); // :param\n\n  return new RegExp(`^${regexString}$`);\n};\n\n/**\n * Replaces route parameters in a path with provided values.\n */\nconst fillPath = (pattern: string, params: string[]) => {\n  let index = 0;\n  return (\n    pattern\n      .replace(/:([^/\\\\*+?]+)[*+?]?/g, () => params[index++] ?? '')\n      .replace(/\\/+/g, '/')\n      .replace(/\\/$/, '') || '/'\n  );\n};\n\n/**\n * Extract values from a URL based on a pattern.\n */\nconst extractParams = (url: string, pattern: string): string[] | null => {\n  const regex = patternToRegex(pattern);\n  const match = url.match(regex);\n  return match ? match.slice(1) : null;\n};\n\n/**\n * Given a localized URL (e.g., \"/produits/123\"), finds the canonical internal path (e.g., \"/products/123\").\n * If locale is provided, only check for that locale. Otherwise, check for all locales.\n */\nexport const getCanonicalPath = <\n  const Path extends string,\n  const Locale extends LocalesValues = LocalesValues,\n>(\n  localizedPath: Path,\n  locale?: Locale,\n  rewriteRules?: RewriteRules\n): string => {\n  if (\n    !rewriteRules ||\n    (process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n      process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false')\n  )\n    return localizedPath;\n\n  for (const rule of rewriteRules.rules) {\n    const { canonical, localized } = rule;\n    const localesToCheck = locale ? [locale] : Object.keys(localized);\n\n    for (const loc of localesToCheck) {\n      const localizedPattern = localized[loc as keyof typeof localized];\n\n      if (!localizedPattern) continue;\n\n      const params = extractParams(localizedPath, localizedPattern);\n\n      if (params) {\n        return fillPath(canonical, params);\n      }\n    }\n  }\n\n  return localizedPath;\n};\n\n/**\n * Given a canonical path (e.g., \"/products/123\"), finds the localized URL pattern\n * (e.g., \"/produits/123\") and reports whether a rule actually matched.\n *\n * Takes already-normalized rules, so callers that resolve the rules once (proxies,\n * static emitters) can reuse them. {@link getLocalizedPath} is the user-facing\n * counterpart: it accepts the raw `routing.rewrite` configuration, defaults to the\n * project configuration, and returns the path alone.\n *\n * @param canonicalPath - The internal application path (e.g. `/product/:id`, `/about`).\n * @param locale - The target locale. Defaults to the configured default locale.\n * @param rewriteRules - Normalized rules, as returned by {@link getRewriteRules}.\n * @returns The localized path, discriminated on whether a rewrite rule matched.\n */\nexport const resolveLocalizedPath = <\n  const CanonicalPath extends string,\n  const Locale extends LocalesValues = ResolvedDefaultLocale,\n>(\n  canonicalPath: CanonicalPath,\n  locale?: Locale,\n  rewriteRules?: RewriteRules\n): LocalizedPathResult<CanonicalPath> => {\n  if (\n    !rewriteRules ||\n    (process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n      process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false')\n  )\n    return { path: canonicalPath, isRewritten: false };\n\n  for (const rule of rewriteRules.rules) {\n    const { canonical, localized } = rule;\n\n    // Check if the input path matches a configured canonical pattern\n    const params = extractParams(canonicalPath, canonical);\n\n    if (params) {\n      const targetLocale = locale ?? internationalization.defaultLocale;\n      const targetPattern = localized[targetLocale as keyof typeof localized];\n\n      if (targetPattern) {\n        return {\n          path: fillPath(targetPattern, params),\n          isRewritten: true,\n        };\n      }\n    }\n  }\n\n  return { path: canonicalPath, isRewritten: false };\n};\n\n/**\n * Returns the internal path for a given canonical path and locale.\n * Ensures the locale prefix is present exactly once.\n */\nexport const getInternalPath = <\n  const Path extends string,\n  const Locale extends LocalesValues,\n>(\n  canonicalPath: Path,\n  locale: Locale\n): InternalPath<Path, Locale> => {\n  const pathWithLeadingSlash = canonicalPath.startsWith('/')\n    ? canonicalPath\n    : `/${canonicalPath}`;\n\n  if (\n    pathWithLeadingSlash.startsWith(`/${locale}/`) ||\n    pathWithLeadingSlash === `/${locale}`\n  ) {\n    return pathWithLeadingSlash as InternalPath<Path, Locale>;\n  }\n\n  return `/${locale}${\n    pathWithLeadingSlash === '/' ? '' : pathWithLeadingSlash\n  }` as InternalPath<Path, Locale>;\n};\n\n/**\n * Given a current pathname and locale, returns the pretty localized path if a rewrite rule exists and the path is not already localized.\n */\nexport const getRewritePath = <\n  const Path extends string,\n  const Locale extends LocalesValues = ResolvedDefaultLocale,\n>(\n  pathname: Path,\n  locale: Locale,\n  rewrite?: RoutingConfig['rewrite']\n): string | undefined => {\n  if (\n    process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n    process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false'\n  )\n    return undefined;\n  const rules = getRewriteRules(rewrite, 'url');\n  if (!rules) return undefined;\n\n  // Identify canonical path (relative to root, no locale prefix expected in 'url' context)\n  const canonicalPath = getCanonicalPath(pathname, undefined, rules);\n\n  // Get the localized path for the current locale\n  const { path: localizedPath, isRewritten } = resolveLocalizedPath(\n    canonicalPath,\n    locale,\n    rules\n  );\n\n  if (isRewritten && localizedPath !== pathname) {\n    return localizedPath;\n  }\n\n  return undefined;\n};\n"],"mappings":"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"}
+{"version":3,"file":"rewriteUtils.mjs","names":[],"sources":["../../../src/localization/rewriteUtils.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { RewriteRules, RoutingConfig } from '@intlayer/types/config';\nimport type {\n  LocalesValues,\n  ResolvedDefaultLocale,\n} from '@intlayer/types/module_augmentation';\nimport { getCanonicalPath } from './getCanonicalPath';\nimport { extractParams, fillPath, getRewriteRules } from './rewriteMatch';\n\n/**\n * Outcome of resolving a canonical path against the rewrite rules.\n *\n * Discriminated on `isRewritten`: when no rule matched, `path` is the very\n * input that was passed in, so a literal input keeps its literal type. Only a\n * rewritten path is computed at runtime and therefore widens to `string`.\n */\nexport type LocalizedPathResult<CanonicalPath extends string = string> =\n  | { path: CanonicalPath; isRewritten: false }\n  | { path: string; isRewritten: true };\n\n/** Adds the leading slash a path may be missing. */\ntype WithLeadingSlash<Path extends string> = Path extends `/${string}`\n  ? Path\n  : `/${Path}`;\n\n/**\n * Computes the locale-prefixed internal path for a path and a locale, mirroring\n * `getInternalPath`'s runtime behaviour: an already-prefixed path is returned\n * untouched, the root collapses to `/${Locale}` (never a trailing slash), and\n * anything else gets the prefix prepended.\n *\n * Falls back to `string` for a non-literal path, where the prefixed and\n * already-prefixed cases cannot be told apart.\n *\n * @example\n * type A = InternalPath<'/about', 'fr'>;    // '/fr/about'\n * type B = InternalPath<'/', 'fr'>;         // '/fr'\n * type C = InternalPath<'/fr/about', 'fr'>; // '/fr/about' (already prefixed)\n */\nexport type InternalPath<\n  Path extends string,\n  Locale extends string,\n> = string extends Path\n  ? string\n  : WithLeadingSlash<Path> extends infer Prefixed extends string\n    ? Prefixed extends `/${Locale}` | `/${Locale}/${string}`\n      ? Prefixed\n      : Prefixed extends '/'\n        ? `/${Locale}`\n        : `/${Locale}${Prefixed}`\n    : never;\n\n/**\n * Given a canonical path (e.g., \"/products/123\"), finds the localized URL pattern\n * (e.g., \"/produits/123\") and reports whether a rule actually matched.\n *\n * Takes already-normalized rules, so callers that resolve the rules once (proxies,\n * static emitters) can reuse them. {@link getLocalizedPath} is the user-facing\n * counterpart: it accepts the raw `routing.rewrite` configuration, defaults to the\n * project configuration, and returns the path alone.\n *\n * @param canonicalPath - The internal application path (e.g. `/product/:id`, `/about`).\n * @param locale - The target locale. Defaults to the configured default locale.\n * @param rewriteRules - Normalized rules, as returned by {@link getRewriteRules}.\n * @returns The localized path, discriminated on whether a rewrite rule matched.\n */\nexport const resolveLocalizedPath = <\n  const CanonicalPath extends string,\n  const Locale extends LocalesValues = ResolvedDefaultLocale,\n>(\n  canonicalPath: CanonicalPath,\n  locale?: Locale,\n  rewriteRules?: RewriteRules\n): LocalizedPathResult<CanonicalPath> => {\n  if (\n    !rewriteRules ||\n    (process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n      process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false')\n  )\n    return { path: canonicalPath, isRewritten: false };\n\n  for (const rule of rewriteRules.rules) {\n    const { canonical, localized } = rule;\n\n    // Check if the input path matches a configured canonical pattern\n    const params = extractParams(canonicalPath, canonical);\n\n    if (params) {\n      const targetLocale = locale ?? internationalization.defaultLocale;\n      const targetPattern = localized[targetLocale as keyof typeof localized];\n\n      if (targetPattern) {\n        return {\n          path: fillPath(targetPattern, params),\n          isRewritten: true,\n        };\n      }\n    }\n  }\n\n  return { path: canonicalPath, isRewritten: false };\n};\n\n/**\n * Returns the internal path for a given canonical path and locale.\n * Ensures the locale prefix is present exactly once.\n */\nexport const getInternalPath = <\n  const Path extends string,\n  const Locale extends LocalesValues,\n>(\n  canonicalPath: Path,\n  locale: Locale\n): InternalPath<Path, Locale> => {\n  const pathWithLeadingSlash = canonicalPath.startsWith('/')\n    ? canonicalPath\n    : `/${canonicalPath}`;\n\n  if (\n    pathWithLeadingSlash.startsWith(`/${locale}/`) ||\n    pathWithLeadingSlash === `/${locale}`\n  ) {\n    return pathWithLeadingSlash as InternalPath<Path, Locale>;\n  }\n\n  return `/${locale}${\n    pathWithLeadingSlash === '/' ? '' : pathWithLeadingSlash\n  }` as InternalPath<Path, Locale>;\n};\n\n/**\n * Given a current pathname and locale, returns the pretty localized path if a rewrite rule exists and the path is not already localized.\n */\nexport const getRewritePath = <\n  const Path extends string,\n  const Locale extends LocalesValues = ResolvedDefaultLocale,\n>(\n  pathname: Path,\n  locale: Locale,\n  rewrite?: RoutingConfig['rewrite']\n): string | undefined => {\n  if (\n    process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n    process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false'\n  )\n    return undefined;\n  const rules = getRewriteRules(rewrite, 'url');\n  if (!rules) return undefined;\n\n  // Identify canonical path (relative to root, no locale prefix expected in 'url' context)\n  const canonicalPath = getCanonicalPath(pathname, undefined, rules);\n\n  // Get the localized path for the current locale\n  const { path: localizedPath, isRewritten } = resolveLocalizedPath(\n    canonicalPath,\n    locale,\n    rules\n  );\n\n  if (isRewritten && localizedPath !== pathname) {\n    return localizedPath;\n  }\n\n  return undefined;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkEA,MAAa,wBAIX,eACA,QACA,iBACuC;CACvC,IACE,CAAC,gBACA,QAAQ,IAAI,kCACX,QAAQ,IAAI,mCAAmC,SAEjD,OAAO;EAAE,MAAM;EAAe,aAAa;CAAM;CAEnD,KAAK,MAAM,QAAQ,aAAa,OAAO;EACrC,MAAM,EAAE,WAAW,cAAc;EAGjC,MAAM,SAAS,cAAc,eAAe,SAAS;EAErD,IAAI,QAAQ;GAEV,MAAM,gBAAgB,UADD,UAAU,qBAAqB;GAGpD,IAAI,eACF,OAAO;IACL,MAAM,SAAS,eAAe,MAAM;IACpC,aAAa;GACf;EAEJ;CACF;CAEA,OAAO;EAAE,MAAM;EAAe,aAAa;CAAM;AACnD;;;;;AAMA,MAAa,mBAIX,eACA,WAC+B;CAC/B,MAAM,uBAAuB,cAAc,WAAW,GAAG,IACrD,gBACA,IAAI;CAER,IACE,qBAAqB,WAAW,IAAI,OAAO,EAAE,KAC7C,yBAAyB,IAAI,UAE7B,OAAO;CAGT,OAAO,IAAI,SACT,yBAAyB,MAAM,KAAK;AAExC;;;;AAKA,MAAa,kBAIX,UACA,QACA,YACuB;CACvB,IACE,QAAQ,IAAI,kCACZ,QAAQ,IAAI,mCAAmC,SAE/C,OAAO;CACT,MAAM,QAAQ,gBAAgB,SAAS,KAAK;CAC5C,IAAI,CAAC,OAAO,OAAO;CAGnB,MAAM,gBAAgB,iBAAiB,UAAU,QAAW,KAAK;CAGjE,MAAM,EAAE,MAAM,eAAe,gBAAgB,qBAC3C,eACA,QACA,KACF;CAEA,IAAI,eAAe,kBAAkB,UACnC,OAAO;AAIX"}

package/dist/esm/localization/rewriteUtils.test-d.mjs

@@ -1,4 +1,4 @@
-import { getCanonicalPath, getInternalPath, resolveLocalizedPath } from "./rewriteUtils.mjs";
+import { getInternalPath, resolveLocalizedPath } from "./rewriteUtils.mjs";
 import { describe, expectTypeOf, it } from "vitest";
 
 //#region src/localization/rewriteUtils.test-d.ts
@@ -38,11 +38,6 @@ describe("resolveLocalizedPath", () => {
 		expectTypeOf(resolveLocalizedPath("/about")).toEqualTypeOf();
 	});
 });
-describe("getCanonicalPath", () => {
-	it("should accept an omitted locale (checks every locale)", () => {
-		expectTypeOf(getCanonicalPath("/a-propos")).toEqualTypeOf();
-	});
-});
 
 //#endregion
 //# sourceMappingURL=rewriteUtils.test-d.mjs.map

package/dist/esm/localization/rewriteUtils.test-d.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rewriteUtils.test-d.mjs","names":[],"sources":["../../../src/localization/rewriteUtils.test-d.ts"],"sourcesContent":["import { describe, expectTypeOf, it } from 'vitest';\nimport {\n  getCanonicalPath,\n  getInternalPath,\n  resolveLocalizedPath,\n} from './rewriteUtils';\n\n/**\n * `getInternalPath` is pure string surgery — no rewrite rules involved — so its\n * result is fully derivable from the arguments whenever both are literals.\n */\ndescribe('getInternalPath', () => {\n  it('should prefix a literal path with the locale', () => {\n    expectTypeOf(getInternalPath('/about', 'fr')).toEqualTypeOf<'/fr/about'>();\n  });\n\n  it('should collapse the root to a bare prefix, never a trailing slash', () => {\n    expectTypeOf(getInternalPath('/', 'fr')).toEqualTypeOf<'/fr'>();\n  });\n\n  it('should leave an already-prefixed path untouched', () => {\n    expectTypeOf(\n      getInternalPath('/fr/about', 'fr')\n    ).toEqualTypeOf<'/fr/about'>();\n    expectTypeOf(getInternalPath('/fr', 'fr')).toEqualTypeOf<'/fr'>();\n  });\n\n  it('should add the leading slash a path is missing', () => {\n    expectTypeOf(getInternalPath('about', 'fr')).toEqualTypeOf<'/fr/about'>();\n  });\n\n  it('should widen to string when the path is not a literal', () => {\n    const dynamicPath = '/about' as string;\n\n    expectTypeOf(getInternalPath(dynamicPath, 'fr')).toEqualTypeOf<string>();\n  });\n});\n\n/**\n * `resolveLocalizedPath` only computes a new path when a rule matched, so the\n * `isRewritten: false` branch still carries the exact input it was given.\n */\ndescribe('resolveLocalizedPath', () => {\n  it('should keep the input literal on the non-rewritten branch', () => {\n    const result = resolveLocalizedPath('/about', 'fr');\n\n    if (!result.isRewritten) {\n      expectTypeOf(result.path).toEqualTypeOf<'/about'>();\n    } else {\n      expectTypeOf(result.path).toEqualTypeOf<string>();\n    }\n  });\n\n  it('should discriminate on isRewritten', () => {\n    expectTypeOf(resolveLocalizedPath('/about')).toEqualTypeOf<\n      | { path: '/about'; isRewritten: false }\n      | { path: string; isRewritten: true }\n    >();\n  });\n});\n\ndescribe('getCanonicalPath', () => {\n  it('should accept an omitted locale (checks every locale)', () => {\n    expectTypeOf(getCanonicalPath('/a-propos')).toEqualTypeOf<string>();\n  });\n});\n"],"mappings":";;;;;;;;AAWA,SAAS,yBAAyB;CAChC,GAAG,sDAAsD;EACvD,aAAa,gBAAgB,UAAU,IAAI,CAAC,CAAC,CAAC,cAA2B;CAC3E,CAAC;CAED,GAAG,2EAA2E;EAC5E,aAAa,gBAAgB,KAAK,IAAI,CAAC,CAAC,CAAC,cAAqB;CAChE,CAAC;CAED,GAAG,yDAAyD;EAC1D,aACE,gBAAgB,aAAa,IAAI,CACnC,CAAC,CAAC,cAA2B;EAC7B,aAAa,gBAAgB,OAAO,IAAI,CAAC,CAAC,CAAC,cAAqB;CAClE,CAAC;CAED,GAAG,wDAAwD;EACzD,aAAa,gBAAgB,SAAS,IAAI,CAAC,CAAC,CAAC,cAA2B;CAC1E,CAAC;CAED,GAAG,+DAA+D;EAGhE,aAAa,gBAAgB,UAAa,IAAI,CAAC,CAAC,CAAC,cAAsB;CACzE,CAAC;AACH,CAAC;;;;;AAMD,SAAS,8BAA8B;CACrC,GAAG,mEAAmE;EACpE,MAAM,SAAS,qBAAqB,UAAU,IAAI;EAElD,IAAI,CAAC,OAAO,aACV,aAAa,OAAO,IAAI,CAAC,CAAC,cAAwB;OAElD,aAAa,OAAO,IAAI,CAAC,CAAC,cAAsB;CAEpD,CAAC;CAED,GAAG,4CAA4C;EAC7C,aAAa,qBAAqB,QAAQ,CAAC,CAAC,CAAC,cAG3C;CACJ,CAAC;AACH,CAAC;AAED,SAAS,0BAA0B;CACjC,GAAG,+DAA+D;EAChE,aAAa,iBAAiB,WAAW,CAAC,CAAC,CAAC,cAAsB;CACpE,CAAC;AACH,CAAC"}
+{"version":3,"file":"rewriteUtils.test-d.mjs","names":[],"sources":["../../../src/localization/rewriteUtils.test-d.ts"],"sourcesContent":["import { describe, expectTypeOf, it } from 'vitest';\nimport { getInternalPath, resolveLocalizedPath } from './rewriteUtils';\n\n/**\n * `getInternalPath` is pure string surgery — no rewrite rules involved — so its\n * result is fully derivable from the arguments whenever both are literals.\n */\ndescribe('getInternalPath', () => {\n  it('should prefix a literal path with the locale', () => {\n    expectTypeOf(getInternalPath('/about', 'fr')).toEqualTypeOf<'/fr/about'>();\n  });\n\n  it('should collapse the root to a bare prefix, never a trailing slash', () => {\n    expectTypeOf(getInternalPath('/', 'fr')).toEqualTypeOf<'/fr'>();\n  });\n\n  it('should leave an already-prefixed path untouched', () => {\n    expectTypeOf(\n      getInternalPath('/fr/about', 'fr')\n    ).toEqualTypeOf<'/fr/about'>();\n    expectTypeOf(getInternalPath('/fr', 'fr')).toEqualTypeOf<'/fr'>();\n  });\n\n  it('should add the leading slash a path is missing', () => {\n    expectTypeOf(getInternalPath('about', 'fr')).toEqualTypeOf<'/fr/about'>();\n  });\n\n  it('should widen to string when the path is not a literal', () => {\n    const dynamicPath = '/about' as string;\n\n    expectTypeOf(getInternalPath(dynamicPath, 'fr')).toEqualTypeOf<string>();\n  });\n});\n\n/**\n * `resolveLocalizedPath` only computes a new path when a rule matched, so the\n * `isRewritten: false` branch still carries the exact input it was given.\n */\ndescribe('resolveLocalizedPath', () => {\n  it('should keep the input literal on the non-rewritten branch', () => {\n    const result = resolveLocalizedPath('/about', 'fr');\n\n    if (!result.isRewritten) {\n      expectTypeOf(result.path).toEqualTypeOf<'/about'>();\n    } else {\n      expectTypeOf(result.path).toEqualTypeOf<string>();\n    }\n  });\n\n  it('should discriminate on isRewritten', () => {\n    expectTypeOf(resolveLocalizedPath('/about')).toEqualTypeOf<\n      | { path: '/about'; isRewritten: false }\n      | { path: string; isRewritten: true }\n    >();\n  });\n});\n"],"mappings":";;;;;;;;AAOA,SAAS,yBAAyB;CAChC,GAAG,sDAAsD;EACvD,aAAa,gBAAgB,UAAU,IAAI,CAAC,CAAC,CAAC,cAA2B;CAC3E,CAAC;CAED,GAAG,2EAA2E;EAC5E,aAAa,gBAAgB,KAAK,IAAI,CAAC,CAAC,CAAC,cAAqB;CAChE,CAAC;CAED,GAAG,yDAAyD;EAC1D,aACE,gBAAgB,aAAa,IAAI,CACnC,CAAC,CAAC,cAA2B;EAC7B,aAAa,gBAAgB,OAAO,IAAI,CAAC,CAAC,CAAC,cAAqB;CAClE,CAAC;CAED,GAAG,wDAAwD;EACzD,aAAa,gBAAgB,SAAS,IAAI,CAAC,CAAC,CAAC,cAA2B;CAC1E,CAAC;CAED,GAAG,+DAA+D;EAGhE,aAAa,gBAAgB,UAAa,IAAI,CAAC,CAAC,CAAC,cAAsB;CACzE,CAAC;AACH,CAAC;;;;;AAMD,SAAS,8BAA8B;CACrC,GAAG,mEAAmE;EACpE,MAAM,SAAS,qBAAqB,UAAU,IAAI;EAElD,IAAI,CAAC,OAAO,aACV,aAAa,OAAO,IAAI,CAAC,CAAC,cAAwB;OAElD,aAAa,OAAO,IAAI,CAAC,CAAC,cAAsB;CAEpD,CAAC;CAED,GAAG,4CAA4C;EAC7C,aAAa,qBAAqB,QAAQ,CAAC,CAAC,CAAC,cAG3C;CACJ,CAAC;AACH,CAAC"}

package/dist/esm/markdown/compiler.mjs

@@ -1,4 +1,4 @@
-import { 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, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CUSTOM_COMPONENT_R, DO_NOT_PROCESS_HTML_ELEMENTS, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FRONT_MATTER_R, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, NAMED_CODES_TO_UNICODE, NP_TABLE_R, ORDERED, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, PARAGRAPH_R, Priority, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, UNORDERED, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R } from "./constants.mjs";
+import { 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, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CUSTOM_COMPONENT_OPENING_TAG_R, CUSTOM_COMPONENT_R, DO_NOT_PROCESS_HTML_ELEMENTS, FOOTNOTE_R, FOOTNOTE_REFERENCE_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_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_SELF_CLOSING_OPENING_TAG_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, NAMED_CODES_TO_UNICODE, NP_TABLE_R, ORDERED, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, PARAGRAPH_R, Priority, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, UNORDERED, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R } from "./constants.mjs";
 import { allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, cx, get, inlineRegex, normalizeAttributeKey, parseBlock, parseCaptureInline, parseInline, parseSimpleInline, parseTableAlign, parseTableCells, parseTableRow, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote } from "./utils.mjs";
 import { parserFor } from "./parser.mjs";
 import { createRenderer, renderFor } from "./renderer.mjs";
@@ -6,19 +6,49 @@ import { createRenderer, renderFor } from "./renderer.mjs";
 //#region src/markdown/compiler.ts
 const IMAGE_R = /^!\[(.*?)\]\( *((?:\([^)]*\)|[^() ])*) *"?([^)"]*)?"?\)/;
 const LINK_R = new RegExp(`^\\[((?:\\[[^\\[\\]]*(?:\\[[^\\[\\]]*\\][^\\[\\]]*)*\\]|[^\\[\\]])*)\\]\\(\\s*<?((?:\\([^)]*\\)|[^\\s\\\\]|\\\\.)*?)>?(?:\\s+['"]([\\s\\S]*?)['"])?\\s*\\)`);
-const getTag = (tag, components) => {
-	if (typeof tag !== "string") return tag;
-	let override = get(components, tag);
-	if (!override && typeof tag === "string") {
-		const lowercaseTag = tag.toLowerCase();
-		const key = Object.keys(components).find((k) => k.toLowerCase() === lowercaseTag);
-		if (key) override = get(components, key);
-	}
-	if (!override) return tag;
-	return override;
+/**
+* Case-insensitive `</tag>` probes, cached per tag name.
+*
+* The `htmlBlock` rule is qualified at every candidate position, and it used to
+* lowercase the whole remaining document to look its closing tag up — copying
+* the rest of the file on each probe.
+*/
+const closingTagRegexCache = /* @__PURE__ */ new Map();
+const getClosingTagRegex = (tag) => {
+	const cached = closingTagRegexCache.get(tag);
+	if (cached) return cached;
+	const regex = new RegExp(`</${tag}>`, "i");
+	closingTagRegexCache.set(tag, regex);
+	return regex;
+};
+/**
+* Builds a tag -> component resolver for one set of overrides.
+*
+* The case-insensitive fallback used to rescan every override key on each
+* element created; the lowercase index is now built once per document instead.
+*/
+const createTagResolver = (components) => {
+	let lowercaseKeys = null;
+	return (tag) => {
+		if (typeof tag !== "string") return tag;
+		const override = get(components, tag);
+		if (override) return override;
+		if (!lowercaseKeys) {
+			lowercaseKeys = /* @__PURE__ */ new Map();
+			for (const key of Object.keys(components)) {
+				const lowercased = key.toLowerCase();
+				if (!lowercaseKeys.has(lowercased)) lowercaseKeys.set(lowercased, key);
+			}
+		}
+		const key = lowercaseKeys.get(tag.toLowerCase());
+		return (key ? get(components, key) : void 0) || tag;
+	};
 };
+/** Resolves the slugifier for a context, falling back to the built-in one. */
+const createSlugger = (ctx) => (input) => ctx.slugify ? ctx.slugify(input, slugify) : slugify(input);
 const createElementFactory = (ctx, options) => {
 	const { runtime, components = {} } = ctx;
+	const resolveTag = createTagResolver(components);
 	const filteredTags = options.tagfilter ? [
 		"title",
 		"textarea",
@@ -49,14 +79,12 @@ const createElementFactory = (ctx, options) => {
 		if (!classNameHandled && className) mergedProps.className = className;
 		let finalProps = mergedProps;
 		if (runtime.normalizeProps && isStringTag) finalProps = runtime.normalizeProps(tag, mergedProps);
-		const component = getTag(tag, components);
+		const component = resolveTag(tag);
 		return runtime.createElement(component, finalProps, ...children.length === 1 ? [children[0]] : children);
 	};
 };
 const createRules = (createElement, ctx, options, footnotes, refs, attrStringToMap, containsBlockSyntax, nonParagraphBlockSyntaxes) => {
-	const slug = (input) => {
-		return ctx.slugify ? ctx.slugify(input, slugify) : slugify(input);
-	};
+	const slug = createSlugger(ctx);
 	const sanitize = ctx.sanitizer ?? sanitizer;
 	const namedCodesToUnicode = ctx.namedCodesToUnicode ? {
 		...NAMED_CODES_TO_UNICODE,
@@ -70,10 +98,11 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 		return {
 			_qualify: (source) => LIST_ITEM_PREFIX_R.test(source),
 			_match: allowInline((source, state) => {
-				const isStartOfLine = LIST_LOOKBEHIND_R.exec(state.prevCapture ?? "");
+				const lineIndent = state.prevCaptureIndent;
+				const isStartOfLine = lineIndent !== void 0;
 				const isListAllowed = state.list ?? (!state.inline && !state.simple);
 				if (isStartOfLine && isListAllowed) {
-					const matchSource = (isStartOfLine[1] || "") + source;
+					const matchSource = lineIndent ? lineIndent + source : source;
 					return LIST_R.exec(matchSource);
 				}
 				return null;
@@ -127,7 +156,7 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 		};
 	};
 	const matchParagraph = (source, state) => {
-		if (state.inline || state.simple || state.inHTML && source.indexOf("\n\n") === -1 && state.prevCapture?.indexOf("\n\n") === -1) return null;
+		if (state.inline || state.simple || state.inHTML && source.indexOf("\n\n") === -1 && !state.prevCaptureHasBlankLine) return null;
 		let start = 0;
 		while (true) {
 			const newlineIndex = source.indexOf("\n", start);
@@ -327,10 +356,9 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 		[RuleType.htmlBlock]: {
 			_qualify: (source) => {
 				if (options.disableParsingRawHTML) return false;
-				const match = source.match(/^ *<([a-z][a-z0-9:-]*)\b/i);
+				const match = HTML_BLOCK_OPENING_TAG_R.exec(source);
 				if (!match) return false;
-				const tag = match[1];
-				return source.toLowerCase().indexOf(`</${tag.toLowerCase()}>`) !== -1;
+				return getClosingTagRegex(match[1]).test(source);
 			},
 			_match: anyScopeRegex(HTML_BLOCK_ELEMENT_R),
 			_order: Priority.HIGH,
@@ -374,7 +402,7 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 		[RuleType.htmlSelfClosing]: {
 			_qualify: (source) => {
 				if (options.disableParsingRawHTML) return false;
-				return /^ *<([a-zA-Z][a-zA-Z0-9:]*)[\s>/]/.test(source);
+				return HTML_SELF_CLOSING_OPENING_TAG_R.test(source);
 			},
 			_match: anyScopeRegex(HTML_SELF_CLOSING_ELEMENT_R),
 			_order: Priority.HIGH,
@@ -393,7 +421,7 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[RuleType.customComponent]: {
-			_qualify: (source) => /^ *<([A-Z][a-zA-Z0-9]*)/.test(source),
+			_qualify: (source) => CUSTOM_COMPONENT_OPENING_TAG_R.test(source),
 			_match: anyScopeRegex(CUSTOM_COMPONENT_R),
 			_order: Priority.MAX,
 			_parse(capture, parse, state) {
@@ -682,10 +710,19 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 		}
 	};
 };
-const parseMarkdown = (markdown = "", ctx, options = {}) => {
-	const dummyCreateElement = () => null;
-	const footnotes = [];
-	const refs = {};
+/**
+* `createElement` is only ever reached from a rule's `_render`, so a parse-only
+* caller can hand over this stub instead of building an element factory.
+*/
+const noopCreateElement = () => null;
+/**
+* Builds the rule set backing one document.
+*
+* Rules close over the document's footnote and reference tables, so they cannot
+* be shared across documents — but a single document's parse and render phases
+* can share one set, which is what `compile` does.
+*/
+const createDocumentRules = (createElement, ctx, options, footnotes, refs) => {
 	const attrStringToMap = (tag, str) => {
 		if (!str?.trim()) return null;
 		const attributes = str.match(ATTR_EXTRACTOR_R);
@@ -714,29 +751,33 @@ const parseMarkdown = (markdown = "", ctx, options = {}) => {
 		UNORDERED_LIST_R,
 		CUSTOM_COMPONENT_R
 	];
+	const blockSyntaxes = options.disableParsingRawHTML ? nonParagraphBlockSyntaxes : [
+		...nonParagraphBlockSyntaxes,
+		PARAGRAPH_R,
+		HTML_BLOCK_ELEMENT_R,
+		HTML_COMMENT_R,
+		HTML_SELF_CLOSING_ELEMENT_R,
+		CUSTOM_COMPONENT_R
+	];
 	const containsBlockSyntax = (input) => {
 		const cleaned = input.replace(TRIM_STARTING_NEWLINES, "");
 		const slice = cleaned.length > 2048 ? cleaned.slice(0, 2048) : cleaned;
 		if (slice.indexOf("\n\n") !== -1) return true;
-		const syntaxes = options.disableParsingRawHTML ? nonParagraphBlockSyntaxes : [
-			...nonParagraphBlockSyntaxes,
-			PARAGRAPH_R,
-			HTML_BLOCK_ELEMENT_R,
-			HTML_COMMENT_R,
-			HTML_SELF_CLOSING_ELEMENT_R,
-			CUSTOM_COMPONENT_R
-		];
-		return some(syntaxes, slice);
+		return some(blockSyntaxes, slice);
 	};
-	const baseRules = createRules(dummyCreateElement, ctx, options, footnotes, refs, attrStringToMap, containsBlockSyntax, nonParagraphBlockSyntaxes);
-	const rules = options.disableParsingRawHTML ? Object.keys(baseRules).reduce((acc, key) => {
+	const baseRules = createRules(createElement, ctx, options, footnotes, refs, attrStringToMap, containsBlockSyntax, nonParagraphBlockSyntaxes);
+	return options.disableParsingRawHTML ? Object.keys(baseRules).reduce((acc, key) => {
 		if (key !== RuleType.htmlBlock && key !== RuleType.htmlSelfClosing) acc[key] = baseRules[key];
 		return acc;
 	}, {}) : baseRules;
+};
+/** Runs the parse phase against an already-built rule set. */
+const parseWithRules = (markdown, options, rules, footnotes, refs) => {
 	const parser = parserFor(rules);
 	const result = options.preserveFrontmatter ? markdown : markdown.replace(FRONT_MATTER_R, "");
-	const inline = options.forceInline || !options.forceBlock && SHOULD_RENDER_AS_BLOCK_R.test(result.replace(TRIM_STARTING_NEWLINES, "")) === false;
-	const ast = parser(inline ? result : `${trimEnd(result).replace(TRIM_STARTING_NEWLINES, "")}\n\n`, { inline });
+	const trimmedStart = result.replace(TRIM_STARTING_NEWLINES, "");
+	const inline = options.forceInline || !options.forceBlock && SHOULD_RENDER_AS_BLOCK_R.test(trimmedStart) === false;
+	const ast = parser(inline ? result : `${trimEnd(trimmedStart)}\n\n`, { inline });
 	if (footnotes.length > 0) for (const def of footnotes) def.parsedAst = parser(def.footnote, { inline: true });
 	return {
 		ast,
@@ -745,21 +786,11 @@ const parseMarkdown = (markdown = "", ctx, options = {}) => {
 		inline
 	};
 };
-const renderMarkdownAst = (parsed, ctx, options = {}) => {
+/** Runs the render phase against an already-built rule set. */
+const renderWithRules = (parsed, ctx, options, rules, createElement) => {
 	const components = ctx.components ?? {};
-	const slug = (input) => {
-		return ctx.slugify ? ctx.slugify(input, slugify) : slugify(input);
-	};
-	const createElement = createElementFactory(ctx, options);
+	const slug = createSlugger(ctx);
 	const footnotes = parsed.footnotes || [];
-	const refs = parsed.references ?? {};
-	const attrStringToMap = () => null;
-	const containsBlockSyntax = () => false;
-	const baseRules = createRules(createElement, ctx, options, footnotes, refs, attrStringToMap, containsBlockSyntax, []);
-	const rules = options.disableParsingRawHTML ? Object.keys(baseRules).reduce((acc, key) => {
-		if (key !== RuleType.htmlBlock && key !== RuleType.htmlSelfClosing) acc[key] = baseRules[key];
-		return acc;
-	}, {}) : baseRules;
 	const emitter = renderFor(createRenderer(rules, options.renderRule));
 	const inline = parsed.inline;
 	const arr = emitter(parsed.ast, { inline });
@@ -794,13 +825,28 @@ const renderMarkdownAst = (parsed, ctx, options = {}) => {
 		key: def.identifier
 	}, def.identifier, emitter(def.parsedAst || def.footnote, { inline: true }))))) : node;
 };
+const parseMarkdown = (markdown = "", ctx, options = {}) => {
+	const footnotes = [];
+	const refs = {};
+	const rules = createDocumentRules(noopCreateElement, ctx, options, footnotes, refs);
+	return parseWithRules(markdown, options, rules, footnotes, refs);
+};
+const renderMarkdownAst = (parsed, ctx, options = {}) => {
+	const createElement = createElementFactory(ctx, options);
+	const rules = createDocumentRules(createElement, ctx, options, parsed.footnotes ?? [], parsed.references ?? {});
+	return renderWithRules(parsed, ctx, options, rules, createElement);
+};
 const compile = (markdown = "", ctx, options = {}) => {
 	if (typeof markdown !== "string") {
 		console.error("intlayer: the first argument must be a string. Received", typeof markdown);
 		throw new Error("intlayer: the first argument must be a string");
 	}
-	const parsed = parseMarkdown(markdown, ctx, options);
-	return renderMarkdownAst(parsed, ctx, options);
+	const footnotes = [];
+	const refs = {};
+	const createElement = createElementFactory(ctx, options);
+	const rules = createDocumentRules(createElement, ctx, options, footnotes, refs);
+	const parsed = parseWithRules(markdown, options, rules, footnotes, refs);
+	return renderWithRules(parsed, ctx, options, rules, createElement);
 };
 const createCompiler = (ctx) => (markdown, options) => compile(markdown, ctx, options);
 const compileWithOptions = (markdown, runtime, options = {}) => {