@intlayer/core 9.4.4 → 9.5.0

package/dist/cjs/markdown/constants.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.cjs","names":[],"sources":["../../../src/markdown/constants.ts"],"sourcesContent":["// ============================================================================\n// RULE TYPES\n// ============================================================================\n\n/**\n * Analogous to `node.type`. Please note that the values here may change at any time,\n * so do not hard code against the value directly.\n */\nexport const RuleType = {\n  blockQuote: '0',\n  breakLine: '1',\n  breakThematic: '2',\n  codeBlock: '3',\n  codeFenced: '4',\n  codeInline: '5',\n  footnote: '6',\n  footnoteReference: '7',\n  gfmTask: '8',\n  heading: '9',\n  headingSetext: '10',\n  /** only available if not `disableHTMLParsing` */\n  htmlBlock: '11',\n  htmlComment: '12',\n  /** only available if not `disableHTMLParsing` */\n  htmlSelfClosing: '13',\n  /** Custom components like <Tabs>, <TabItem> */\n  customComponent: '34',\n  image: '14',\n  link: '15',\n  /** emits a `link` 'node', does not render directly */\n  linkAngleBraceStyleDetector: '16',\n  /** emits a `link` 'node', does not render directly */\n  linkBareUrlDetector: '17',\n  newlineCoalescer: '19',\n  orderedList: '20',\n  paragraph: '21',\n  ref: '22',\n  refImage: '23',\n  refLink: '24',\n  table: '25',\n  tableSeparator: '26',\n  text: '27',\n  textBolded: '28',\n  textEmphasized: '29',\n  textEscaped: '30',\n  textMarked: '31',\n  textStrikethroughed: '32',\n  unorderedList: '33',\n} as const;\n\n// In test environment, use human-readable keys for easier debugging\nif (process.env.NODE_ENV === 'test') {\n  Object.keys(RuleType).forEach((key) => {\n    (RuleType as any)[key] = key;\n  });\n}\n\nexport type RuleTypeValue = (typeof RuleType)[keyof typeof RuleType];\n\n// ============================================================================\n// PRIORITY LEVELS\n// ============================================================================\n\n/**\n * Priority levels for rule ordering.\n */\nexport const Priority = {\n  /** anything that must scan the tree before everything else */\n  MAX: 0,\n  /** scans for block-level constructs */\n  HIGH: 1,\n  /** inline w/ more priority than other inline */\n  MED: 2,\n  /** inline elements */\n  LOW: 3,\n  /** bare text and stuff that is considered leftovers */\n  MIN: 4,\n} as const;\n\nexport type PriorityValue = (typeof Priority)[keyof typeof Priority];\n\n// ============================================================================\n// ATTRIBUTE MAPPING\n// ============================================================================\n\n/**\n * Map of HTML attributes to their JSX prop equivalents.\n * Some renderers use camelCase for certain attributes.\n */\nexport const ATTRIBUTE_TO_NODE_PROP_MAP: Record<string, string> = [\n  'allowFullScreen',\n  'allowTransparency',\n  'autoComplete',\n  'autoFocus',\n  'autoPlay',\n  'cellPadding',\n  'cellSpacing',\n  'charSet',\n  'classId',\n  'colSpan',\n  'contentEditable',\n  'contextMenu',\n  'crossOrigin',\n  'encType',\n  'formAction',\n  'formEncType',\n  'formMethod',\n  'formNoValidate',\n  'formTarget',\n  'frameBorder',\n  'hrefLang',\n  'inputMode',\n  'keyParams',\n  'keyType',\n  'marginHeight',\n  'marginWidth',\n  'maxLength',\n  'mediaGroup',\n  'minLength',\n  'noValidate',\n  'radioGroup',\n  'readOnly',\n  'rowSpan',\n  'spellCheck',\n  'srcDoc',\n  'srcLang',\n  'srcSet',\n  'tabIndex',\n  'useMap',\n].reduce(\n  (obj: Record<string, string>, x) => {\n    obj[x.toLowerCase()] = x;\n    return obj;\n  },\n  { class: 'className', for: 'htmlFor' }\n);\n\n// ============================================================================\n// NAMED CODES TO UNICODE\n// ============================================================================\n\n/**\n * Default HTML entity to unicode mappings.\n */\nexport const NAMED_CODES_TO_UNICODE: Record<string, string> = {\n  amp: '\\u0026',\n  apos: '\\u0027',\n  gt: '\\u003e',\n  lt: '\\u003c',\n  nbsp: '\\u00a0',\n  quot: '\\u201c',\n};\n\n// ============================================================================\n// SPECIAL ELEMENTS\n// ============================================================================\n\n/** HTML elements that should not have their content processed */\nexport const DO_NOT_PROCESS_HTML_ELEMENTS = ['style', 'script', 'pre'];\n\n/** Attributes that require URL sanitization */\nexport const ATTRIBUTES_TO_SANITIZE = [\n  'src',\n  'href',\n  'data',\n  'formAction',\n  'srcDoc',\n  'action',\n];\n\n// ============================================================================\n// REGEX PATTERNS\n// ============================================================================\n\n/** Attribute extractor regex */\nexport const ATTR_EXTRACTOR_R =\n  /([-A-Z0-9_:]+)(?:\\s*=\\s*(?:(?:\"((?:\\\\.|[^\"])*)\")|(?:'((?:\\\\.|[^'])*)')|(?:\\{((?:\\\\.|{[^}]*?}|[^}])*)\\})))?/gi;\n\n/** Block end detection */\nexport const BLOCK_END_R = /\\n{2,}$/;\n\n/** Blockquote patterns */\nexport const BLOCKQUOTE_R = /^(\\s*>[\\s\\S]*?)(?=\\n\\n|$)/;\nexport const BLOCKQUOTE_TRIM_LEFT_MULTILINE_R = /^ *> ?/gm;\nexport const BLOCKQUOTE_ALERT_R = /^(?:\\[!([^\\]]*)\\]\\n)?([\\s\\S]*)/;\n\n/** Line break patterns */\nexport const BREAK_LINE_R = /^ {2,}\\n/;\nexport const BREAK_THEMATIC_R = /^(?:([-*_])( *\\1){2,}) *(?:\\n *)+\\n/;\n\n/** Code block patterns */\nexport const CODE_BLOCK_FENCED_R =\n  /^(?: {1,3})?(`{3,}|~{3,}) *(\\S+)? *([^\\n]*?)?\\n([\\s\\S]*?)(?:\\1\\n?|$)/;\nexport const CODE_BLOCK_R = /^(?: {4}[^\\n]+\\n*)+(?:\\n *)+\\n?/;\n/** A single line opening or closing a fenced code block, with its indentation. */\nexport const FENCE_DELIMITER_R = /^([ \\t]*)(`{3,}|~{3,})/;\nexport const CODE_INLINE_R = /^(`+)((?:\\\\`|(?!\\1)`|[^`])+)\\1/;\n\n/** Newline patterns */\nexport const CONSECUTIVE_NEWLINE_R = /^(?:\\n *)*\\n/;\nexport const CR_NEWLINE_R = /\\r\\n?/g;\n\n/** Footnote patterns */\nexport const FOOTNOTE_R = /^\\[\\^([^\\]]+)](:(.*)((\\n+ {4,}.*)|(\\n(?!\\[\\^).+))*)/;\nexport const FOOTNOTE_REFERENCE_R = /^\\[\\^([^\\]]+)]/;\n\n/** Form feed */\nexport const FORMFEED_R = /\\f/g;\n\n/** Front matter */\nexport const FRONT_MATTER_R = /^---[ \\t]*\\n(.|\\n)*?\\n---[ \\t]*\\n/;\n\n/** GFM task */\nexport const GFM_TASK_R = /^\\s*?\\[(x|\\s)\\]/;\n\n/** Heading patterns */\nexport const HEADING_R = /^ *(#{1,6}) *([^\\n]+?)(?: +#*)?(?:\\n *)*(?:\\n|$)/;\nexport const HEADING_ATX_COMPLIANT_R =\n  /^ *(#{1,6}) +([^\\n]+?)(?: +#*)?(?:\\n *)*(?:\\n|$)/;\nexport const HEADING_SETEXT_R = /^([^\\n]+)\\n *(=|-)\\2{2,} *\\n/;\n\n/** HTML patterns */\n\n/**\n * Run of characters carrying no meaning inside an opening tag: neither a quote\n * opening a value nor an angle bracket delimiting a tag.\n */\nconst TAG_PLAIN_RUN = `[^>\"'<]*`;\n\n/**\n * Quoted attribute value. It may hold an angle bracket —\n * `<Tab label='Intlayer >=9.4'>` — but not a line break, which keeps a tag that\n * turns out not to match from trying every later quote of the document as its\n * closing one.\n */\nconst TAG_QUOTED_VALUE = `\"[^\"\\\\n]*\"|'[^'\\\\n]*'`;\n\n/**\n * Attribute list of an opening tag, written as a plain run followed by\n * quote-or-bracket-led segments so that each character has a single way to be\n * read. A lone quote is allowed last so a tag holding an unbalanced one still\n * parses, as it did before quoted values were recognised.\n */\nconst TAG_ATTRIBUTES = `${TAG_PLAIN_RUN}(?:(?:${TAG_QUOTED_VALUE}|<.*?>|[\"'])${TAG_PLAIN_RUN})*`;\n\n/** Rejects the opening tag of a self-closing element, `<div class=\"a\"/>`. */\nconst NOT_SELF_CLOSING = `(?![^>]*/>)`;\n\n/**\n * Opening tag of a nested element bearing the same name as the outer one. This\n * one stays a plain scan up to the first `>`: it is tried at every character of\n * the element's content, and a richer pattern here costs an order of magnitude\n * on documents whose tag never closes.\n */\nconst NESTED_SAME_TAG_OPENING = `<\\\\1[^>]*?>`;\n\nexport const HTML_BLOCK_ELEMENT_R = new RegExp(\n  `^ *(?!<[a-zA-Z][^ >/]* ?/>)<([a-zA-Z][^ >/]*) ?(${NOT_SELF_CLOSING}${TAG_ATTRIBUTES})>\\\\n?(\\\\s*(?:${NESTED_SAME_TAG_OPENING}[\\\\s\\\\S]*?</\\\\1>|(?!<\\\\1\\\\b)[\\\\s\\\\S])*?)</\\\\1>(?!</\\\\1>)\\\\n*`,\n  'i'\n);\nexport const HTML_CHAR_CODE_R =\n  /&([a-z0-9]+|#[0-9]{1,6}|#x[0-9a-fA-F]{1,6});/gi;\nexport const HTML_COMMENT_R = /^<!--[\\s\\S]*?(?:-->)/;\nexport const HTML_CUSTOM_ATTR_R = /^(data|aria|x)-[a-z_][a-z\\d_.-]*$/;\nexport const HTML_SELF_CLOSING_ELEMENT_R = new RegExp(\n  `^ *<([a-zA-Z][a-zA-Z0-9:]*)(?:\\\\s+(${TAG_ATTRIBUTES}))?/?>(?!</\\\\1>)(\\\\s*\\\\n)?`,\n  'i'\n);\n\n/** Custom component pattern */\nexport const CUSTOM_COMPONENT_R = new RegExp(\n  `^ *<([A-Z][a-zA-Z0-9]*)(?:\\\\s+(${TAG_ATTRIBUTES}))?>\\\\n?(\\\\s*(?:${NESTED_SAME_TAG_OPENING}[\\\\s\\\\S]*?</\\\\1>|(?!<\\\\1\\\\b)[\\\\s\\\\S])*?)</\\\\1>(?!</\\\\1>)\\\\n*`\n);\n\n/** Interpolation */\nexport const INTERPOLATION_R = /^\\{.*\\}$/;\n\n/** Link patterns */\nexport const LINK_AUTOLINK_BARE_URL_R = /^(https?:\\/\\/[^\\s<]+[^<.,:;\"')\\]\\s])/;\nexport const LINK_AUTOLINK_R = /^<([^ >]+[:@/][^ >]+)>/;\nexport const CAPTURE_LETTER_AFTER_HYPHEN = /-([a-z])?/gi;\n\n/** Table patterns */\nexport const NP_TABLE_R =\n  /^(\\|.*)\\n(?: *(\\|? *[-:]+ *\\|[-| :]*)\\n((?:.*\\|.*\\n)*))?\\n?/;\nexport const TABLE_TRIM_PIPES = /(^ *\\||\\| *$)/g;\nexport const TABLE_CENTER_ALIGN = /^ *:-+: *$/;\nexport const TABLE_LEFT_ALIGN = /^ *:-+ *$/;\nexport const TABLE_RIGHT_ALIGN = /^ *-+: *$/;\n\n/** Paragraph */\nexport const PARAGRAPH_R = /^[^\\n]+(?: {2}\\n|\\n{2,})/;\n\n/** Reference patterns */\nexport const REFERENCE_IMAGE_OR_LINK =\n  /^\\[([^\\]]*)\\]:\\s+<?([^\\s>]+)>?\\s*(\"([^\"]*)\")?/;\nexport const REFERENCE_IMAGE_R = /^!\\[([^\\]]*)\\] ?\\[([^\\]]*)\\]/;\nexport const REFERENCE_LINK_R = /^\\[([^\\]]*)\\] ?\\[([^\\]]*)\\]/;\n\n/**\n * Cheap prefix probes used to reject a rule before its full (and far more\n * expensive) block regex runs. Kept as module constants so the parser's inner\n * loop never allocates a `RegExp` per candidate position.\n */\nexport const HTML_BLOCK_OPENING_TAG_R = /^ *<([a-z][a-z0-9:-]*)\\b/i;\nexport const HTML_SELF_CLOSING_OPENING_TAG_R =\n  /^ *<([a-zA-Z][a-zA-Z0-9:]*)[\\s>/]/;\nexport const CUSTOM_COMPONENT_OPENING_TAG_R = /^ *<([A-Z][a-zA-Z0-9]*)/;\n\n/** Block detection */\nexport const SHOULD_RENDER_AS_BLOCK_R = /(\\n|^[-*]\\s|^#|^ {2,}|^-{2,}|^>\\s)/;\n\n/** Tab and whitespace */\nexport const TAB_R = /\\t/g;\n/** Every character `normalizeWhitespace` rewrites, so it needs a single pass. */\nexport const NORMALIZE_WHITESPACE_R = /\\r\\n?|\\f|\\t/g;\nexport const TRIM_STARTING_NEWLINES = /^\\n+/;\nexport const HTML_LEFT_TRIM_AMOUNT_R = /^\\n*([ \\t]*)/;\n\n/** List patterns */\nexport const ORDERED_LIST_BULLET = '(?:\\\\d+\\\\.)';\nexport const UNORDERED_LIST_BULLET = '(?:[*+-])';\n\n/** Text formatting patterns */\nexport const TEXT_ESCAPED_R = /^\\\\([^0-9A-Za-z\\s])/;\nexport const UNESCAPE_R = /\\\\([^0-9A-Za-z\\s])/g;\nexport const TEXT_PLAIN_R =\n  /^[\\s\\S](?:(?! {2}\\n|[0-9]\\.|http)[^=*_~\\-\\n:<`\\\\[!])*/;\n\n/** Shortcode pattern */\nexport const SHORTCODE_R = /^(:[a-zA-Z0-9-_]+:)/;\n\n// ============================================================================\n// LIST TYPE CONSTANTS\n// ============================================================================\n\nexport type ListType = 1 | 2;\nexport const ORDERED: ListType = 1;\nexport const UNORDERED: ListType = 2;\n\n// ============================================================================\n// INLINE PATTERN HELPERS\n// ============================================================================\n\n/**\n * Ensure there's at least one more instance of the delimiter later\n * in the current sequence.\n */\nexport const LOOKAHEAD = (double: number): string =>\n  `(?=[\\\\s\\\\S]+?\\\\1${double ? '\\\\1' : ''})`;\n\n/**\n * For inline formatting, this partial attempts to ignore characters that\n * may appear in nested formatting.\n */\nexport const INLINE_SKIP_R =\n  '((?:\\\\[.*?\\\\][([].*?[)\\\\]]|<.*?>(?:.*?<.*?>)?|`.*?`|\\\\\\\\[^\\\\s]|[\\\\s\\\\S])+?)';\n\n/** Bold text pattern */\nexport const TEXT_BOLD_R = new RegExp(\n  `^([*_])\\\\1${LOOKAHEAD(1)}${INLINE_SKIP_R}\\\\1\\\\1(?!\\\\1)`\n);\n\n/** Emphasized text pattern */\nexport const TEXT_EMPHASIZED_R = new RegExp(\n  `^([*_])${LOOKAHEAD(0)}${INLINE_SKIP_R}\\\\1(?!\\\\1)`\n);\n\n/** Marked text pattern */\nexport const TEXT_MARKED_R = new RegExp(\n  `^(==)${LOOKAHEAD(0)}${INLINE_SKIP_R}\\\\1`\n);\n\n/** Strikethrough text pattern */\nexport const TEXT_STRIKETHROUGHED_R = new RegExp(\n  `^(~~)${LOOKAHEAD(0)}${INLINE_SKIP_R}\\\\1`\n);\n\n// ============================================================================\n// LIST REGEX GENERATORS\n// ============================================================================\n\nexport const generateListItemPrefix = (type: ListType): string => {\n  return (\n    '( *)(' +\n    (type === ORDERED ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET) +\n    ') +'\n  );\n};\n\nexport const ORDERED_LIST_ITEM_PREFIX = generateListItemPrefix(ORDERED);\nexport const UNORDERED_LIST_ITEM_PREFIX = generateListItemPrefix(UNORDERED);\n\nexport const generateListItemPrefixRegex = (type: ListType): RegExp => {\n  return new RegExp(\n    '^' +\n      (type === ORDERED ? ORDERED_LIST_ITEM_PREFIX : UNORDERED_LIST_ITEM_PREFIX)\n  );\n};\n\nexport const ORDERED_LIST_ITEM_PREFIX_R = generateListItemPrefixRegex(ORDERED);\nexport const UNORDERED_LIST_ITEM_PREFIX_R =\n  generateListItemPrefixRegex(UNORDERED);\n\nexport const generateListItemRegex = (type: ListType): RegExp => {\n  return new RegExp(\n    '^' +\n      (type === ORDERED\n        ? ORDERED_LIST_ITEM_PREFIX\n        : UNORDERED_LIST_ITEM_PREFIX) +\n      '[^\\\\n]*(?:\\\\n' +\n      '(?!\\\\1' +\n      (type === ORDERED ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET) +\n      ' )[^\\\\n]*)*(\\\\n|$)',\n    'gm'\n  );\n};\n\nexport const ORDERED_LIST_ITEM_R = generateListItemRegex(ORDERED);\nexport const UNORDERED_LIST_ITEM_R = generateListItemRegex(UNORDERED);\n\nexport const generateListRegex = (type: ListType): RegExp => {\n  const bullet = type === ORDERED ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET;\n\n  return new RegExp(\n    '^( *)(' +\n      bullet +\n      ') ' +\n      '[\\\\s\\\\S]+?(?:\\\\n{2,}(?! )' +\n      '(?!\\\\1' +\n      bullet +\n      ' (?!' +\n      bullet +\n      ' ))\\\\n*' +\n      '|\\\\s*\\\\n*$)'\n  );\n};\n\nexport const ORDERED_LIST_R = generateListRegex(ORDERED);\nexport const UNORDERED_LIST_R = generateListRegex(UNORDERED);\n"],"mappings":"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"}
+{"version":3,"file":"constants.cjs","names":[],"sources":["../../../src/markdown/constants.ts"],"sourcesContent":["// ============================================================================\n// RULE TYPES\n// ============================================================================\n\n/**\n * Analogous to `node.type`. Please note that the values here may change at any time,\n * so do not hard code against the value directly.\n */\nexport const RuleType = {\n  blockQuote: '0',\n  breakLine: '1',\n  breakThematic: '2',\n  codeBlock: '3',\n  codeFenced: '4',\n  codeInline: '5',\n  footnote: '6',\n  footnoteReference: '7',\n  gfmTask: '8',\n  heading: '9',\n  headingSetext: '10',\n  /** only available if not `disableHTMLParsing` */\n  htmlBlock: '11',\n  htmlComment: '12',\n  /** only available if not `disableHTMLParsing` */\n  htmlSelfClosing: '13',\n  /** Custom components like <Tabs>, <TabItem> */\n  customComponent: '34',\n  image: '14',\n  link: '15',\n  /** emits a `link` 'node', does not render directly */\n  linkAngleBraceStyleDetector: '16',\n  /** emits a `link` 'node', does not render directly */\n  linkBareUrlDetector: '17',\n  newlineCoalescer: '19',\n  orderedList: '20',\n  paragraph: '21',\n  ref: '22',\n  refImage: '23',\n  refLink: '24',\n  table: '25',\n  tableSeparator: '26',\n  text: '27',\n  textBolded: '28',\n  textEmphasized: '29',\n  textEscaped: '30',\n  textMarked: '31',\n  textStrikethroughed: '32',\n  unorderedList: '33',\n} as const;\n\n// In test environment, use human-readable keys for easier debugging\nif (process.env.NODE_ENV === 'test') {\n  Object.keys(RuleType).forEach((key) => {\n    (RuleType as any)[key] = key;\n  });\n}\n\nexport type RuleTypeValue = (typeof RuleType)[keyof typeof RuleType];\n\n// ============================================================================\n// PRIORITY LEVELS\n// ============================================================================\n\n/**\n * Priority levels for rule ordering.\n */\nexport const Priority = {\n  /** anything that must scan the tree before everything else */\n  MAX: 0,\n  /** scans for block-level constructs */\n  HIGH: 1,\n  /** inline w/ more priority than other inline */\n  MED: 2,\n  /** inline elements */\n  LOW: 3,\n  /** bare text and stuff that is considered leftovers */\n  MIN: 4,\n} as const;\n\nexport type PriorityValue = (typeof Priority)[keyof typeof Priority];\n\n// ============================================================================\n// RULE SCOPE CONSTANTS\n// ============================================================================\n\n/**\n * Parsing scope for markdown rules.\n * Bitmask representation for fast bitwise checking and bundle minification.\n * - BLOCK (1): evaluated only when !state.inline && !state.simple\n * - INLINE (2): evaluated only when state.inline || state.simple\n * - BOTH (3): evaluated in both scopes (default)\n */\nexport const RuleScope = {\n  BLOCK: 1,\n  INLINE: 2,\n  BOTH: 3,\n} as const;\n\nexport const SCOPE_BLOCK = RuleScope.BLOCK;\nexport const SCOPE_INLINE = RuleScope.INLINE;\nexport const SCOPE_BOTH = RuleScope.BOTH;\n\nexport type RuleScopeValue =\n  | (typeof RuleScope)[keyof typeof RuleScope]\n  | 'block'\n  | 'inline'\n  | 'both';\n\n// ============================================================================\n// ATTRIBUTE MAPPING\n// ============================================================================\n\n/**\n * Map of HTML attributes to their JSX prop equivalents.\n * Some renderers use camelCase for certain attributes.\n */\nexport const ATTRIBUTE_TO_NODE_PROP_MAP: Record<string, string> = [\n  'allowFullScreen',\n  'allowTransparency',\n  'autoComplete',\n  'autoFocus',\n  'autoPlay',\n  'cellPadding',\n  'cellSpacing',\n  'charSet',\n  'classId',\n  'colSpan',\n  'contentEditable',\n  'contextMenu',\n  'crossOrigin',\n  'encType',\n  'formAction',\n  'formEncType',\n  'formMethod',\n  'formNoValidate',\n  'formTarget',\n  'frameBorder',\n  'hrefLang',\n  'inputMode',\n  'keyParams',\n  'keyType',\n  'marginHeight',\n  'marginWidth',\n  'maxLength',\n  'mediaGroup',\n  'minLength',\n  'noValidate',\n  'radioGroup',\n  'readOnly',\n  'rowSpan',\n  'spellCheck',\n  'srcDoc',\n  'srcLang',\n  'srcSet',\n  'tabIndex',\n  'useMap',\n].reduce(\n  (obj: Record<string, string>, x) => {\n    obj[x.toLowerCase()] = x;\n    return obj;\n  },\n  { class: 'className', for: 'htmlFor' }\n);\n\n// ============================================================================\n// NAMED CODES TO UNICODE\n// ============================================================================\n\n/**\n * Default HTML entity to unicode mappings.\n */\nexport const NAMED_CODES_TO_UNICODE: Record<string, string> = {\n  amp: '\\u0026',\n  apos: '\\u0027',\n  gt: '\\u003e',\n  lt: '\\u003c',\n  nbsp: '\\u00a0',\n  quot: '\\u201c',\n};\n\n// ============================================================================\n// SPECIAL ELEMENTS\n// ============================================================================\n\n/** HTML elements that should not have their content processed */\nexport const DO_NOT_PROCESS_HTML_ELEMENTS = ['style', 'script', 'pre'];\n\n/** Attributes that require URL sanitization */\nexport const ATTRIBUTES_TO_SANITIZE = [\n  'src',\n  'href',\n  'data',\n  'formAction',\n  'srcDoc',\n  'action',\n];\n\n// ============================================================================\n// REGEX PATTERNS\n// ============================================================================\n\n/** Attribute extractor regex */\nexport const ATTR_EXTRACTOR_R =\n  /([-A-Z0-9_:]+)(?:\\s*=\\s*(?:(?:\"((?:\\\\.|[^\"])*)\")|(?:'((?:\\\\.|[^'])*)')|(?:\\{((?:\\\\.|{[^}]*?}|[^}])*)\\})))?/gi;\n\n/** Block end detection */\nexport const BLOCK_END_R = /\\n{2,}$/;\n\n/** Blockquote patterns */\nexport const BLOCKQUOTE_R = /^(\\s*>[\\s\\S]*?)(?=\\n\\n|$)/;\nexport const BLOCKQUOTE_TRIM_LEFT_MULTILINE_R = /^ *> ?/gm;\nexport const BLOCKQUOTE_ALERT_R = /^(?:\\[!([^\\]]*)\\]\\n)?([\\s\\S]*)/;\n\n/** Line break patterns */\nexport const BREAK_LINE_R = /^(?=( {2,}))\\1\\n/;\nexport const BREAK_THEMATIC_R = /^(?:([-*_])( *\\1){2,}) *(?:\\n *)+\\n/;\n\n/** Code block patterns */\n// The body is consumed a whole line at a time rather than character by\n// character: a closing fence only ever starts a line, so the backreference is\n// tested once per line instead of once per character. The trailing `$` branch\n// inside the loop keeps an unterminated fence that ends without a newline.\nexport const CODE_BLOCK_FENCED_R =\n  /^(?: {1,3})?(`{3,}|~{3,}) *(\\S+)? *([^\\n]*?)?\\n((?:[^\\n]*(?:\\n|$))*?)(?:\\1\\n?|$)/;\nexport const CODE_BLOCK_R = /^(?: {4}[^\\n]+\\n*)+(?:\\n *)+\\n?/;\n/** A single line opening or closing a fenced code block, with its indentation. */\nexport const FENCE_DELIMITER_R = /^([ \\t]*)(`{3,}|~{3,})/;\nexport const CODE_INLINE_R = /^(`+)((?:\\\\`|(?!\\1)`|[^`])+)\\1/;\n\n/** Newline patterns */\nexport const CONSECUTIVE_NEWLINE_R = /^(?:\\n *)*\\n/;\nexport const CR_NEWLINE_R = /\\r\\n?/g;\n\n/** Footnote patterns */\nexport const FOOTNOTE_R = /^\\[\\^([^\\]]+)](:(.*)((\\n+ {4,}.*)|(\\n(?!\\[\\^).+))*)/;\nexport const FOOTNOTE_REFERENCE_R = /^\\[\\^([^\\]]+)]/;\n\n/** Form feed */\nexport const FORMFEED_R = /\\f/g;\n\n/** Front matter */\nexport const FRONT_MATTER_R = /^---[ \\t]*\\n(.|\\n)*?\\n---[ \\t]*\\n/;\n\n/** GFM task */\nexport const GFM_TASK_R = /^\\s*?\\[(x|\\s)\\]/;\n\n/** Heading patterns */\nexport const HEADING_R = /^ *(#{1,6}) *([^\\n]+?)(?: +#*)?(?:\\n *)*(?:\\n|$)/;\nexport const HEADING_ATX_COMPLIANT_R =\n  /^ *(#{1,6}) +([^\\n]+?)(?: +#*)?(?:\\n *)*(?:\\n|$)/;\nexport const HEADING_SETEXT_R = /^([^\\n]+)\\n *(=|-)\\2{2,} *\\n/;\n\n/** HTML patterns */\n\nexport const HTML_CHAR_CODE_R =\n  /&([a-z0-9]+|#[0-9]{1,6}|#x[0-9a-fA-F]{1,6});/gi;\nexport const HTML_COMMENT_R = /^<!--[\\s\\S]*?(?:-->)/;\nexport const HTML_CUSTOM_ATTR_R = /^(data|aria|x)-[a-z_][a-z\\d_.-]*$/;\n\n/** Interpolation */\nexport const INTERPOLATION_R = /^\\{.*\\}$/;\n\n/** Link patterns */\nexport const LINK_AUTOLINK_BARE_URL_R = /^(https?:\\/\\/[^\\s<]+[^<.,:;\"')\\]\\s])/;\nexport const LINK_AUTOLINK_R = /^<([^ >]+[:@/][^ >]+)>/;\nexport const CAPTURE_LETTER_AFTER_HYPHEN = /-([a-z])?/gi;\n\n/**\n * Table patterns.\n *\n * The row scans spell \"any character but a newline\" as `[^\\n]` rather than `.`:\n * `.` is a four-range exclusion, and matching it over rows this wide costs a\n * third more than the single-range class. It is also the more faithful reading\n * — only `\\n` ends a line here, and `\\r` is normalized away before parsing.\n */\nexport const NP_TABLE_R =\n  /^(\\|[^\\n]*)\\n(?: *(\\|? *[-:]+ *\\|[-| :]*)\\n((?:[^\\n]*\\|[^\\n]*\\n)*))?\\n?/;\nexport const TABLE_TRIM_PIPES = /(^ *\\||\\| *$)/g;\nexport const TABLE_CENTER_ALIGN = /^ *:-+: *$/;\nexport const TABLE_LEFT_ALIGN = /^ *:-+ *$/;\nexport const TABLE_RIGHT_ALIGN = /^ *-+: *$/;\n\n/** Paragraph */\nexport const PARAGRAPH_R = /^[^\\n]+(?: {2}\\n|\\n{2,})/;\n\n/** Reference patterns */\nexport const REFERENCE_IMAGE_OR_LINK =\n  /^\\[([^\\]]*)\\]:\\s+<?([^\\s>]+)>?\\s*(\"([^\"]*)\")?/;\nexport const REFERENCE_IMAGE_R = /^!\\[([^\\]]*)\\] ?\\[([^\\]]*)\\]/;\nexport const REFERENCE_LINK_R = /^\\[([^\\]]*)\\] ?\\[([^\\]]*)\\]/;\n\n/** Block detection */\nexport const SHOULD_RENDER_AS_BLOCK_R = /(\\n|^[-*]\\s|^#|^ {2,}|^-{2,}|^>\\s)/;\n\n/** Tabs, which `normalizeWhitespace` widens to four spaces. */\nexport const TAB_R = /\\t/g;\nexport const TRIM_STARTING_NEWLINES = /^\\n+/;\nexport const HTML_LEFT_TRIM_AMOUNT_R = /^\\n*([ \\t]*)/;\n\n/** List patterns */\nexport const ORDERED_LIST_BULLET = '(?:\\\\d+\\\\.)';\nexport const UNORDERED_LIST_BULLET = '(?:[*+-])';\n\n/** Text formatting patterns */\nexport const TEXT_ESCAPED_R = /^\\\\([^0-9A-Za-z\\s])/;\nexport const UNESCAPE_R = /\\\\([^0-9A-Za-z\\s])/g;\n\n/** Shortcode pattern */\nexport const SHORTCODE_R = /^(:[a-zA-Z0-9-_]+:)/;\n\n// ============================================================================\n// LIST TYPE CONSTANTS\n// ============================================================================\n\nexport type ListType = 1 | 2;\nexport const ORDERED: ListType = 1;\nexport const UNORDERED: ListType = 2;\n\n// ============================================================================\n// INLINE PATTERN HELPERS\n// ============================================================================\n\n/**\n * Ensure there's at least one more instance of the delimiter later\n * in the current sequence.\n */\nexport const LOOKAHEAD = (double: number): string =>\n  `(?=[\\\\s\\\\S]+?\\\\1${double ? '\\\\1' : ''})`;\n\n/**\n * For inline formatting, this partial attempts to ignore characters that\n * may appear in nested formatting.\n */\nexport const INLINE_SKIP_R =\n  '((?:\\\\[.*?\\\\][([].*?[)\\\\]]|<.*?>(?:.*?<.*?>)?|`.*?`|\\\\\\\\[^\\\\s]|[\\\\s\\\\S])+?)';\n\n/** Bold text pattern */\nexport const TEXT_BOLD_R = new RegExp(\n  `^([*_])\\\\1${LOOKAHEAD(1)}${INLINE_SKIP_R}\\\\1\\\\1(?!\\\\1)`\n);\n\n/** Emphasized text pattern */\nexport const TEXT_EMPHASIZED_R = new RegExp(\n  `^([*_])${LOOKAHEAD(0)}${INLINE_SKIP_R}\\\\1(?!\\\\1)`\n);\n\n/** Marked text pattern */\nexport const TEXT_MARKED_R = new RegExp(\n  `^(==)${LOOKAHEAD(0)}${INLINE_SKIP_R}\\\\1`\n);\n\n/** Strikethrough text pattern */\nexport const TEXT_STRIKETHROUGHED_R = new RegExp(\n  `^(~~)${LOOKAHEAD(0)}${INLINE_SKIP_R}\\\\1`\n);\n\n// ============================================================================\n// LIST REGEX GENERATORS\n// ============================================================================\n\nexport const generateListItemPrefix = (type: ListType): string => {\n  return (\n    '( *)(' +\n    (type === ORDERED ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET) +\n    ') +'\n  );\n};\n\nexport const ORDERED_LIST_ITEM_PREFIX = generateListItemPrefix(ORDERED);\nexport const UNORDERED_LIST_ITEM_PREFIX = generateListItemPrefix(UNORDERED);\n\nexport const generateListItemPrefixRegex = (type: ListType): RegExp => {\n  return new RegExp(\n    '^' +\n      (type === ORDERED ? ORDERED_LIST_ITEM_PREFIX : UNORDERED_LIST_ITEM_PREFIX)\n  );\n};\n\nexport const ORDERED_LIST_ITEM_PREFIX_R = generateListItemPrefixRegex(ORDERED);\nexport const UNORDERED_LIST_ITEM_PREFIX_R =\n  generateListItemPrefixRegex(UNORDERED);\n\nexport const generateListItemRegex = (type: ListType): RegExp => {\n  return new RegExp(\n    '^' +\n      (type === ORDERED\n        ? ORDERED_LIST_ITEM_PREFIX\n        : UNORDERED_LIST_ITEM_PREFIX) +\n      '[^\\\\n]*(?:\\\\n' +\n      '(?!\\\\1' +\n      (type === ORDERED ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET) +\n      ' )[^\\\\n]*)*(\\\\n|$)',\n    'gm'\n  );\n};\n\nexport const ORDERED_LIST_ITEM_R = generateListItemRegex(ORDERED);\nexport const UNORDERED_LIST_ITEM_R = generateListItemRegex(UNORDERED);\n\nexport const generateListRegex = (type: ListType): RegExp => {\n  const bullet = type === ORDERED ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET;\n\n  return new RegExp(\n    '^( *)(' +\n      bullet +\n      ') ' +\n      // The body advances a line at a time rather than a character at a time: a\n      // list can only end at a line boundary, so the terminator — the expensive\n      // half, with its two nested lookaheads — is tried once per line instead of\n      // once per character. The step swallows the newline that used to open the\n      // terminator, which is why it now reads `\\n+` and not `\\n{2,}`, and the\n      // leading lookahead keeps a source with nothing left after the bullet from\n      // matching through a zero-width step.\n      '(?=[\\\\s\\\\S])(?:[^\\\\n]*(?:\\\\n|$))+?' +\n      '(?:\\\\n+(?! )' +\n      '(?!\\\\1' +\n      bullet +\n      ' (?!' +\n      bullet +\n      ' ))\\\\n*' +\n      // `\\s` already covers `\\n`, so the trailing `\\n*` the pattern used to\n      // carry could only ever match empty — and paying for it at every step of\n      // the lazy scan cost a third of the whole match.\n      '|\\\\s*$)'\n  );\n};\n\nexport const ORDERED_LIST_R = generateListRegex(ORDERED);\nexport const UNORDERED_LIST_R = generateListRegex(UNORDERED);\n"],"mappings":"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"}

package/dist/cjs/markdown/elementScanner.cjs

@@ -0,0 +1,191 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region src/markdown/elementScanner.ts
+/**
+* Lean, non-backtracking element scanner for HTML blocks, custom components, and self-closing tags.
+*/
+const findTagEnd = (source, from) => {
+	const len = source.length;
+	let pos = from;
+	while (pos < len) {
+		const code = source.charCodeAt(pos);
+		if (code === 62) return pos;
+		if (code === 34 || code === 39) {
+			let cur = pos + 1;
+			while (cur < len && source.charCodeAt(cur) !== code && source.charCodeAt(cur) !== 10) cur++;
+			pos = source.charCodeAt(cur) === code ? cur + 1 : pos + 1;
+			continue;
+		}
+		pos++;
+	}
+	return -1;
+};
+/** Fold an ASCII upper-case letter to lower case, leaving anything else alone. */
+const foldAscii = (code) => code >= 65 && code <= 90 ? code + 32 : code;
+/**
+* Compare `needle` against `source` at `at`, ignoring ASCII case.
+*
+* HTML tag names are case-insensitive, and the scanner asks this question once
+* per `<` it walks past — so it must not allocate. Slicing the candidate out and
+* lower-casing it built two strings per question, which is what made the tag
+* walk the most expensive frame in an element-heavy document.
+*/
+const matchesFolded = (source, needle, at) => {
+	for (let index = 0; index < needle.length; index++) if (foldAscii(source.charCodeAt(at + index)) !== foldAscii(needle.charCodeAt(index))) return false;
+	return true;
+};
+/**
+* Index of the next `needle` tag at or after `from`, or -1 when there is none
+* starting before `limit`.
+*
+* `limit` is what keeps the nesting walk linear: an opening tag only matters
+* when it precedes the closing one, so searching past the closing tag walks the
+* rest of the document — once per element — for an answer that is thrown away.
+*/
+const findTag = (source, needle, from, caseInsensitive, limit) => {
+	if (!caseInsensitive) {
+		const idx = source.indexOf(needle, from);
+		return idx === -1 || idx >= limit ? -1 : idx;
+	}
+	const max = Math.min(limit, source.length - needle.length + 1);
+	let pos = from;
+	while (pos < max) {
+		const idx = source.indexOf("<", pos);
+		if (idx === -1 || idx >= max) return -1;
+		if (matchesFolded(source, needle, idx)) return idx;
+		pos = idx + 1;
+	}
+	return -1;
+};
+const makeMatch = (source, end, tagName, attrs, content) => {
+	const result = [
+		source.slice(0, end),
+		tagName,
+		attrs,
+		content
+	];
+	result.index = 0;
+	result.input = source;
+	return result;
+};
+/** ASCII letter or digit — the characters a tag name is built from. */
+const isNameChar = (code) => code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57;
+const skipLeadingSpaces = (source) => {
+	let i = 0;
+	while (source.charCodeAt(i) === 32) i++;
+	return source.charCodeAt(i) === 60 ? i : -1;
+};
+const matchElement = (source, customComponent) => {
+	const bracket = skipLeadingSpaces(source);
+	if (bracket === -1) return null;
+	const nameStart = bracket + 1;
+	let nameEnd = nameStart;
+	const first = source.charCodeAt(nameStart);
+	if (customComponent) {
+		if (first < 65 || first > 90) return null;
+		while (nameEnd < source.length && isNameChar(source.charCodeAt(nameEnd))) nameEnd++;
+	} else {
+		if (!(first >= 65 && first <= 90 || first >= 97 && first <= 122)) return null;
+		while (nameEnd < source.length) {
+			const c = source.charCodeAt(nameEnd);
+			if (c === 32 || c === 9 || c === 10 || c === 13 || c === 62 || c === 47) break;
+			nameEnd++;
+		}
+	}
+	const tagName = source.slice(nameStart, nameEnd);
+	const openTagEnd = findTagEnd(source, nameEnd);
+	if (openTagEnd === -1) return null;
+	if (!customComponent && source.charCodeAt(openTagEnd - 1) === 47) return null;
+	let contentStart = openTagEnd + 1;
+	if (source.charCodeAt(contentStart) === 10) contentStart++;
+	const openTag = `<${tagName}`;
+	const closeTag = `</${tagName}`;
+	let depth = 1;
+	let cursor = contentStart;
+	const len = source.length;
+	let contentEnd = -1;
+	let end = -1;
+	while (cursor < len) {
+		const closeIdx = findTag(source, closeTag, cursor, !customComponent, len);
+		if (closeIdx === -1) return null;
+		const openIdx = findTag(source, openTag, cursor, !customComponent, closeIdx);
+		if (openIdx !== -1) {
+			const next = source.charCodeAt(openIdx + openTag.length);
+			if (next === 32 || next === 9 || next === 10 || next === 13 || next === 62 || next === 47) {
+				const nestedEnd = findTagEnd(source, openIdx + openTag.length);
+				if (nestedEnd === -1) return null;
+				depth++;
+				cursor = nestedEnd + 1;
+			} else cursor = openIdx + 1;
+			continue;
+		}
+		if (source.charCodeAt(closeIdx + closeTag.length) !== 62) {
+			cursor = closeIdx + 1;
+			continue;
+		}
+		const closeTagEnd = closeIdx + closeTag.length + 1;
+		depth--;
+		if (depth > 0) {
+			cursor = closeTagEnd;
+			continue;
+		}
+		if (findTag(source, closeTag, closeTagEnd, !customComponent, len) === closeTagEnd && source.charCodeAt(closeTagEnd + closeTag.length) === 62) {
+			depth = 1;
+			cursor = closeTagEnd;
+			continue;
+		}
+		contentEnd = closeIdx;
+		end = closeTagEnd;
+		break;
+	}
+	if (end === -1) return null;
+	while (source.charCodeAt(end) === 10) end++;
+	return makeMatch(source, end, tagName, source.slice(nameEnd, openTagEnd), source.slice(contentStart, contentEnd));
+};
+const matchSelfClosingElement = (source) => {
+	const bracket = skipLeadingSpaces(source);
+	if (bracket === -1) return null;
+	const nameStart = bracket + 1;
+	const first = source.charCodeAt(nameStart);
+	if (!(first >= 65 && first <= 90 || first >= 97 && first <= 122)) return null;
+	let nameEnd = nameStart + 1;
+	while (nameEnd < source.length && (isNameChar(source.charCodeAt(nameEnd)) || source.charCodeAt(nameEnd) === 58)) nameEnd++;
+	const c = source.charCodeAt(nameEnd);
+	const hasAttrs = c === 32 || c === 9 || c === 10 || c === 13;
+	let tagEnd;
+	if (hasAttrs) {
+		tagEnd = findTagEnd(source, nameEnd);
+		if (tagEnd === -1) return null;
+	} else {
+		tagEnd = source.charCodeAt(nameEnd) === 47 ? nameEnd + 1 : nameEnd;
+		if (source.charCodeAt(tagEnd) !== 62) return null;
+	}
+	const tagName = source.slice(nameStart, nameEnd);
+	const tailStart = tagEnd + 1;
+	if (source.charCodeAt(tailStart) === 60 && source.charCodeAt(tailStart + 1) === 47 && matchesFolded(source, tagName, tailStart + 2) && source.charCodeAt(tailStart + 2 + tagName.length) === 62) return null;
+	let end = tailStart;
+	let scan = tailStart;
+	while (scan < source.length) {
+		const sc = source.charCodeAt(scan);
+		if (sc !== 32 && sc !== 9 && sc !== 10 && sc !== 13) break;
+		scan++;
+		if (source.charCodeAt(scan - 1) === 10) end = scan;
+	}
+	return makeMatch(source, end, tagName, hasAttrs ? source.slice(nameEnd + 1, tagEnd) : void 0, end > tailStart ? source.slice(tailStart, end) : void 0);
+};
+const matchHtmlBlockElement = (source) => matchElement(source, false);
+const matchCustomComponent = (source) => matchElement(source, true);
+const startsWithHtmlBlockElement = (source) => matchHtmlBlockElement(source) !== null;
+const startsWithSelfClosingElement = (source) => matchSelfClosingElement(source) !== null;
+const startsWithCustomComponent = (source) => matchCustomComponent(source) !== null;
+const startsWithElement = (source) => startsWithHtmlBlockElement(source) || startsWithSelfClosingElement(source);
+
+//#endregion
+exports.matchCustomComponent = matchCustomComponent;
+exports.matchElement = matchElement;
+exports.matchHtmlBlockElement = matchHtmlBlockElement;
+exports.matchSelfClosingElement = matchSelfClosingElement;
+exports.startsWithCustomComponent = startsWithCustomComponent;
+exports.startsWithElement = startsWithElement;
+exports.startsWithHtmlBlockElement = startsWithHtmlBlockElement;
+exports.startsWithSelfClosingElement = startsWithSelfClosingElement;
+//# sourceMappingURL=elementScanner.cjs.map

package/dist/cjs/markdown/elementScanner.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementScanner.cjs","names":[],"sources":["../../../src/markdown/elementScanner.ts"],"sourcesContent":["/**\n * Lean, non-backtracking element scanner for HTML blocks, custom components, and self-closing tags.\n */\n\nconst findTagEnd = (source: string, from: number): number => {\n  const len = source.length;\n  let pos = from;\n  while (pos < len) {\n    const code = source.charCodeAt(pos);\n    if (code === 62) return pos; // '>'\n    if (code === 34 || code === 39) {\n      // '\"' or \"'\"\n      let cur = pos + 1;\n      while (\n        cur < len &&\n        source.charCodeAt(cur) !== code &&\n        source.charCodeAt(cur) !== 10\n      )\n        cur++;\n      pos = source.charCodeAt(cur) === code ? cur + 1 : pos + 1;\n      continue;\n    }\n    pos++;\n  }\n  return -1;\n};\n\n/** Fold an ASCII upper-case letter to lower case, leaving anything else alone. */\nconst foldAscii = (code: number): number =>\n  code >= 65 && code <= 90 ? code + 32 : code;\n\n/**\n * Compare `needle` against `source` at `at`, ignoring ASCII case.\n *\n * HTML tag names are case-insensitive, and the scanner asks this question once\n * per `<` it walks past — so it must not allocate. Slicing the candidate out and\n * lower-casing it built two strings per question, which is what made the tag\n * walk the most expensive frame in an element-heavy document.\n */\nconst matchesFolded = (source: string, needle: string, at: number): boolean => {\n  for (let index = 0; index < needle.length; index++) {\n    if (\n      foldAscii(source.charCodeAt(at + index)) !==\n      foldAscii(needle.charCodeAt(index))\n    ) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * Index of the next `needle` tag at or after `from`, or -1 when there is none\n * starting before `limit`.\n *\n * `limit` is what keeps the nesting walk linear: an opening tag only matters\n * when it precedes the closing one, so searching past the closing tag walks the\n * rest of the document — once per element — for an answer that is thrown away.\n */\nconst findTag = (\n  source: string,\n  needle: string,\n  from: number,\n  caseInsensitive: boolean,\n  limit: number\n): number => {\n  if (!caseInsensitive) {\n    const idx = source.indexOf(needle, from);\n    return idx === -1 || idx >= limit ? -1 : idx;\n  }\n  const max = Math.min(limit, source.length - needle.length + 1);\n  let pos = from;\n  while (pos < max) {\n    const idx = source.indexOf('<', pos);\n    if (idx === -1 || idx >= max) return -1;\n    if (matchesFolded(source, needle, idx)) return idx;\n    pos = idx + 1;\n  }\n  return -1;\n};\n\nconst makeMatch = (\n  source: string,\n  end: number,\n  tagName: string,\n  attrs?: string,\n  content?: string\n): RegExpMatchArray => {\n  const result = [\n    source.slice(0, end),\n    tagName,\n    attrs,\n    content,\n  ] as unknown as RegExpMatchArray;\n  result.index = 0;\n  result.input = source;\n  return result;\n};\n\n/** ASCII letter or digit — the characters a tag name is built from. */\nconst isNameChar = (code: number): boolean =>\n  (code >= 97 && code <= 122) ||\n  (code >= 65 && code <= 90) ||\n  (code >= 48 && code <= 57);\n\nconst skipLeadingSpaces = (source: string): number => {\n  let i = 0;\n  while (source.charCodeAt(i) === 32) i++;\n  return source.charCodeAt(i) === 60 ? i : -1;\n};\n\nexport const matchElement = (\n  source: string,\n  customComponent: boolean\n): RegExpMatchArray | null => {\n  const bracket = skipLeadingSpaces(source);\n  if (bracket === -1) return null;\n\n  const nameStart = bracket + 1;\n  let nameEnd = nameStart;\n  const first = source.charCodeAt(nameStart);\n\n  if (customComponent) {\n    if (first < 65 || first > 90) return null; // [A-Z]\n    while (nameEnd < source.length && isNameChar(source.charCodeAt(nameEnd)))\n      nameEnd++;\n  } else {\n    if (!((first >= 65 && first <= 90) || (first >= 97 && first <= 122)))\n      return null;\n    while (nameEnd < source.length) {\n      const c = source.charCodeAt(nameEnd);\n      if (c === 32 || c === 9 || c === 10 || c === 13 || c === 62 || c === 47)\n        break;\n      nameEnd++;\n    }\n  }\n\n  const tagName = source.slice(nameStart, nameEnd);\n  const openTagEnd = findTagEnd(source, nameEnd);\n  if (openTagEnd === -1) return null;\n  if (!customComponent && source.charCodeAt(openTagEnd - 1) === 47) return null;\n\n  let contentStart = openTagEnd + 1;\n  if (source.charCodeAt(contentStart) === 10) contentStart++;\n\n  const openTag = `<${tagName}`;\n  const closeTag = `</${tagName}`;\n\n  let depth = 1;\n  let cursor = contentStart;\n  const len = source.length;\n  let contentEnd = -1;\n  let end = -1;\n\n  while (cursor < len) {\n    const closeIdx = findTag(source, closeTag, cursor, !customComponent, len);\n\n    if (closeIdx === -1) return null;\n\n    const openIdx = findTag(\n      source,\n      openTag,\n      cursor,\n      !customComponent,\n      closeIdx\n    );\n\n    if (openIdx !== -1) {\n      const next = source.charCodeAt(openIdx + openTag.length);\n      if (\n        next === 32 ||\n        next === 9 ||\n        next === 10 ||\n        next === 13 ||\n        next === 62 ||\n        next === 47\n      ) {\n        const nestedEnd = findTagEnd(source, openIdx + openTag.length);\n        if (nestedEnd === -1) return null;\n        depth++;\n        cursor = nestedEnd + 1;\n      } else {\n        cursor = openIdx + 1;\n      }\n      continue;\n    }\n\n    if (source.charCodeAt(closeIdx + closeTag.length) !== 62) {\n      cursor = closeIdx + 1;\n      continue;\n    }\n\n    const closeTagEnd = closeIdx + closeTag.length + 1;\n    depth--;\n\n    if (depth > 0) {\n      cursor = closeTagEnd;\n      continue;\n    }\n\n    // (?!</\\1>)\n    if (\n      findTag(source, closeTag, closeTagEnd, !customComponent, len) ===\n        closeTagEnd &&\n      source.charCodeAt(closeTagEnd + closeTag.length) === 62\n    ) {\n      depth = 1;\n      cursor = closeTagEnd;\n      continue;\n    }\n\n    contentEnd = closeIdx;\n    end = closeTagEnd;\n    break;\n  }\n\n  if (end === -1) return null;\n  while (source.charCodeAt(end) === 10) end++;\n\n  return makeMatch(\n    source,\n    end,\n    tagName,\n    source.slice(nameEnd, openTagEnd),\n    source.slice(contentStart, contentEnd)\n  );\n};\n\nexport const matchSelfClosingElement = (\n  source: string\n): RegExpMatchArray | null => {\n  const bracket = skipLeadingSpaces(source);\n  if (bracket === -1) return null;\n\n  const nameStart = bracket + 1;\n  const first = source.charCodeAt(nameStart);\n  if (!((first >= 65 && first <= 90) || (first >= 97 && first <= 122)))\n    return null;\n\n  let nameEnd = nameStart + 1;\n  while (\n    nameEnd < source.length &&\n    (isNameChar(source.charCodeAt(nameEnd)) ||\n      source.charCodeAt(nameEnd) === 58) /* : */\n  )\n    nameEnd++;\n\n  const c = source.charCodeAt(nameEnd);\n  const hasAttrs = c === 32 || c === 9 || c === 10 || c === 13;\n  let tagEnd: number;\n\n  if (hasAttrs) {\n    tagEnd = findTagEnd(source, nameEnd);\n    if (tagEnd === -1) return null;\n  } else {\n    tagEnd = source.charCodeAt(nameEnd) === 47 ? nameEnd + 1 : nameEnd;\n    if (source.charCodeAt(tagEnd) !== 62) return null;\n  }\n\n  const tagName = source.slice(nameStart, nameEnd);\n  const tailStart = tagEnd + 1;\n\n  // `<tag/></tag>` is a paired element written oddly, not a self-closing one.\n  if (\n    source.charCodeAt(tailStart) === 60 /* < */ &&\n    source.charCodeAt(tailStart + 1) === 47 /* / */ &&\n    matchesFolded(source, tagName, tailStart + 2) &&\n    source.charCodeAt(tailStart + 2 + tagName.length) === 62 /* > */\n  ) {\n    return null;\n  }\n\n  let end = tailStart;\n  let scan = tailStart;\n  while (scan < source.length) {\n    const sc = source.charCodeAt(scan);\n    if (sc !== 32 && sc !== 9 && sc !== 10 && sc !== 13) break;\n    scan++;\n    if (source.charCodeAt(scan - 1) === 10) end = scan;\n  }\n\n  return makeMatch(\n    source,\n    end,\n    tagName,\n    hasAttrs ? source.slice(nameEnd + 1, tagEnd) : undefined,\n    end > tailStart ? source.slice(tailStart, end) : undefined\n  );\n};\n\nexport const matchHtmlBlockElement = (source: string) =>\n  matchElement(source, false);\nexport const matchCustomComponent = (source: string) =>\n  matchElement(source, true);\nexport const startsWithHtmlBlockElement = (source: string) =>\n  matchHtmlBlockElement(source) !== null;\nexport const startsWithSelfClosingElement = (source: string) =>\n  matchSelfClosingElement(source) !== null;\nexport const startsWithCustomComponent = (source: string) =>\n  matchCustomComponent(source) !== null;\nexport const startsWithElement = (source: string) =>\n  startsWithHtmlBlockElement(source) || startsWithSelfClosingElement(source);\n"],"mappings":"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"}

package/dist/cjs/markdown/index.cjs

@@ -23,8 +23,6 @@ exports.CODE_BLOCK_R = require_markdown_constants.CODE_BLOCK_R;
 exports.CODE_INLINE_R = require_markdown_constants.CODE_INLINE_R;
 exports.CONSECUTIVE_NEWLINE_R = require_markdown_constants.CONSECUTIVE_NEWLINE_R;
 exports.CR_NEWLINE_R = require_markdown_constants.CR_NEWLINE_R;
-exports.CUSTOM_COMPONENT_OPENING_TAG_R = require_markdown_constants.CUSTOM_COMPONENT_OPENING_TAG_R;
-exports.CUSTOM_COMPONENT_R = require_markdown_constants.CUSTOM_COMPONENT_R;
 exports.DO_NOT_PROCESS_HTML_ELEMENTS = require_markdown_constants.DO_NOT_PROCESS_HTML_ELEMENTS;
 exports.FENCE_DELIMITER_R = require_markdown_constants.FENCE_DELIMITER_R;
 exports.FOOTNOTE_R = require_markdown_constants.FOOTNOTE_R;
@@ -35,21 +33,16 @@ exports.GFM_TASK_R = require_markdown_constants.GFM_TASK_R;
 exports.HEADING_ATX_COMPLIANT_R = require_markdown_constants.HEADING_ATX_COMPLIANT_R;
 exports.HEADING_R = require_markdown_constants.HEADING_R;
 exports.HEADING_SETEXT_R = require_markdown_constants.HEADING_SETEXT_R;
-exports.HTML_BLOCK_ELEMENT_R = require_markdown_constants.HTML_BLOCK_ELEMENT_R;
-exports.HTML_BLOCK_OPENING_TAG_R = require_markdown_constants.HTML_BLOCK_OPENING_TAG_R;
 exports.HTML_CHAR_CODE_R = require_markdown_constants.HTML_CHAR_CODE_R;
 exports.HTML_COMMENT_R = require_markdown_constants.HTML_COMMENT_R;
 exports.HTML_CUSTOM_ATTR_R = require_markdown_constants.HTML_CUSTOM_ATTR_R;
 exports.HTML_LEFT_TRIM_AMOUNT_R = require_markdown_constants.HTML_LEFT_TRIM_AMOUNT_R;
-exports.HTML_SELF_CLOSING_ELEMENT_R = require_markdown_constants.HTML_SELF_CLOSING_ELEMENT_R;
-exports.HTML_SELF_CLOSING_OPENING_TAG_R = require_markdown_constants.HTML_SELF_CLOSING_OPENING_TAG_R;
 exports.INLINE_SKIP_R = require_markdown_constants.INLINE_SKIP_R;
 exports.INTERPOLATION_R = require_markdown_constants.INTERPOLATION_R;
 exports.LINK_AUTOLINK_BARE_URL_R = require_markdown_constants.LINK_AUTOLINK_BARE_URL_R;
 exports.LINK_AUTOLINK_R = require_markdown_constants.LINK_AUTOLINK_R;
 exports.LOOKAHEAD = require_markdown_constants.LOOKAHEAD;
 exports.NAMED_CODES_TO_UNICODE = require_markdown_constants.NAMED_CODES_TO_UNICODE;
-exports.NORMALIZE_WHITESPACE_R = require_markdown_constants.NORMALIZE_WHITESPACE_R;
 exports.NP_TABLE_R = require_markdown_constants.NP_TABLE_R;
 exports.ORDERED = require_markdown_constants.ORDERED;
 exports.ORDERED_LIST_BULLET = require_markdown_constants.ORDERED_LIST_BULLET;
@@ -62,7 +55,11 @@ exports.Priority = require_markdown_constants.Priority;
 exports.REFERENCE_IMAGE_OR_LINK = require_markdown_constants.REFERENCE_IMAGE_OR_LINK;
 exports.REFERENCE_IMAGE_R = require_markdown_constants.REFERENCE_IMAGE_R;
 exports.REFERENCE_LINK_R = require_markdown_constants.REFERENCE_LINK_R;
+exports.RuleScope = require_markdown_constants.RuleScope;
 exports.RuleType = require_markdown_constants.RuleType;
+exports.SCOPE_BLOCK = require_markdown_constants.SCOPE_BLOCK;
+exports.SCOPE_BOTH = require_markdown_constants.SCOPE_BOTH;
+exports.SCOPE_INLINE = require_markdown_constants.SCOPE_INLINE;
 exports.SHORTCODE_R = require_markdown_constants.SHORTCODE_R;
 exports.SHOULD_RENDER_AS_BLOCK_R = require_markdown_constants.SHOULD_RENDER_AS_BLOCK_R;
 exports.TABLE_CENTER_ALIGN = require_markdown_constants.TABLE_CENTER_ALIGN;
@@ -74,7 +71,6 @@ exports.TEXT_BOLD_R = require_markdown_constants.TEXT_BOLD_R;
 exports.TEXT_EMPHASIZED_R = require_markdown_constants.TEXT_EMPHASIZED_R;
 exports.TEXT_ESCAPED_R = require_markdown_constants.TEXT_ESCAPED_R;
 exports.TEXT_MARKED_R = require_markdown_constants.TEXT_MARKED_R;
-exports.TEXT_PLAIN_R = require_markdown_constants.TEXT_PLAIN_R;
 exports.TEXT_STRIKETHROUGHED_R = require_markdown_constants.TEXT_STRIKETHROUGHED_R;
 exports.TRIM_STARTING_NEWLINES = require_markdown_constants.TRIM_STARTING_NEWLINES;
 exports.UNESCAPE_R = require_markdown_constants.UNESCAPE_R;
@@ -100,6 +96,7 @@ exports.generateListItemRegex = require_markdown_constants.generateListItemRegex
 exports.generateListRegex = require_markdown_constants.generateListRegex;
 exports.get = require_markdown_utils.get;
 exports.getMarkdownMetadata = require_transpiler_markdown_getMarkdownMetadata.getMarkdownMetadata;
+exports.getRuleSet = require_markdown_compiler.getRuleSet;
 exports.inlineRegex = require_markdown_utils.inlineRegex;
 exports.md = require_transpiler_markdown_markdown.md;
 exports.normalizeAttributeKey = require_markdown_utils.normalizeAttributeKey;

package/dist/cjs/markdown/parser.cjs

@@ -1,30 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_markdown_constants = require('./constants.cjs');
 const require_markdown_utils = require('./utils.cjs');
 
 //#region src/markdown/parser.ts
-const ruleOrderCache = /* @__PURE__ */ new Map();
-const sameNames = (a, b) => {
-	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-	return true;
-};
-/**
-* Resolves `Object.keys(rules)` into precedence order, sorting only the first
-* time a given rule set is seen.
-*/
-const orderRules = (names, rules) => {
-	const candidates = ruleOrderCache.get(names.length);
-	if (candidates) {
-		for (let i = 0; i < candidates.length; i++) if (sameNames(names, candidates[i].names)) return candidates[i].order;
-	}
-	const order = names.slice().sort((a, b) => rules[a]._order - rules[b]._order || +a - +b);
-	const entry = {
-		names: names.slice(),
-		order
-	};
-	if (candidates) candidates.push(entry);
-	else ruleOrderCache.set(names.length, [entry]);
-	return order;
-};
 /**
 * Advance the incremental lookbehind carried on the parse state.
 *
@@ -35,10 +13,14 @@ const orderRules = (names, rules) => {
 * rescanning — the whole document, which made parsing quadratic.
 */
 const advanceLookbehind = (state, capture) => {
+	const lastCode = capture.charCodeAt(capture.length - 1);
+	if (state.prevCaptureHasBlankLine !== true) state.prevCaptureHasBlankLine = capture.indexOf("\n\n") !== -1 || state.prevCaptureHasBlankLine !== void 0 && capture.charCodeAt(0) === 10 && state.prevCaptureIndent === "";
+	if (lastCode !== 32 && lastCode !== 10) {
+		state.prevCaptureIndent = void 0;
+		return;
+	}
 	const newlineIndex = capture.lastIndexOf("\n");
-	const hasPrevCapture = state.prevCaptureHasBlankLine !== void 0;
-	if (state.prevCaptureHasBlankLine !== true) state.prevCaptureHasBlankLine = capture.indexOf("\n\n") !== -1 || hasPrevCapture && capture.charCodeAt(0) === 10 && state.prevCaptureIndent === "";
-	const tail = newlineIndex === -1 ? state.prevCaptureIndent === void 0 ? void 0 : state.prevCaptureIndent + capture : capture.slice(newlineIndex + 1);
+	const tail = newlineIndex === -1 ? state.prevCaptureIndent === void 0 ? void 0 : state.prevCaptureIndent === "" ? capture : state.prevCaptureIndent + capture : capture.slice(newlineIndex + 1);
 	if (tail === void 0 || tail === "") {
 		state.prevCaptureIndent = tail;
 		return;
@@ -52,45 +34,105 @@ const advanceLookbehind = (state, capture) => {
 /**
 * 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
 */
 const parserFor = (rules) => {
-	const ruleList = Object.keys(rules);
-	if (process.env.NODE_ENV !== "production") ruleList.forEach((type) => {
-		const order = rules[type]?._order;
-		if (typeof order !== "number" || !Number.isFinite(order)) console.warn(`intlayer: Invalid order for rule \`${type}\`: ${order}`);
-	});
-	const order = orderRules(ruleList, rules);
+	const order = Object.keys(rules).sort((a, b) => rules[a]._order - rules[b]._order || +a - +b);
 	const ruleCount = order.length;
 	const qualifiers = new Array(ruleCount);
 	const matchers = new Array(ruleCount);
 	const parsers = new Array(ruleCount);
+	const ruleFirstChars = new Array(ruleCount);
+	const ruleIsBlock = new Array(ruleCount);
+	const ruleIsInline = new Array(ruleCount);
+	const blockDefaultCandidates = [];
+	const inlineDefaultCandidates = [];
 	for (let i = 0; i < ruleCount; i++) {
 		const rule = rules[order[i]];
-		qualifiers[i] = rule._qualify;
+		let q = rule._qualify;
 		matchers[i] = rule._match;
 		parsers[i] = rule._parse;
+		const rawScope = rule._scope;
+		const isBlock = rawScope !== require_markdown_constants.SCOPE_INLINE;
+		const isInline = rawScope !== require_markdown_constants.SCOPE_BLOCK;
+		ruleIsBlock[i] = isBlock;
+		ruleIsInline[i] = isInline;
+		if (rule._firstChars && rule._firstChars.length > 0) ruleFirstChars[i] = rule._firstChars;
+		else if (Array.isArray(q) && q.length > 0 && q.every((p) => p.length > 0)) {
+			ruleFirstChars[i] = q.map((p) => p.charCodeAt(0));
+			if (q.every((p) => p.length === 1)) q = void 0;
+		} else {
+			ruleFirstChars[i] = null;
+			if (isBlock) blockDefaultCandidates.push(i);
+			if (isInline) inlineDefaultCandidates.push(i);
+		}
+		qualifiers[i] = q;
+	}
+	const blockAsciiCandidates = new Array(128);
+	const inlineAsciiCandidates = new Array(128);
+	for (let code = 0; code < 128; code++) {
+		const bList = [];
+		const iList = [];
+		for (let i = 0; i < ruleCount; i++) {
+			const isBlock = ruleIsBlock[i];
+			const isInline = ruleIsInline[i];
+			const chars = ruleFirstChars[i];
+			if (isBlock && (!chars || chars.includes(code))) bList.push(i);
+			if (isInline && (!chars || chars.includes(code))) iList.push(i);
+		}
+		blockAsciiCandidates[code] = bList;
+		inlineAsciiCandidates[code] = iList;
 	}
 	const nestedParse = (source, state = {}) => {
 		const result = [];
+		const isInline = Boolean(state.inline || state.simple);
 		if (state.prevCaptureHasBlankLine === void 0) state.prevCaptureIndent = "";
-		if (source.trim()) while (source) for (let i = 0; i < ruleCount; i++) {
-			const qualify = qualifiers[i];
-			if (qualify && !require_markdown_utils.qualifies(source, state, qualify)) continue;
-			const capture = matchers[i](source, state);
-			if (capture?.[0]) {
-				source = source.substring(capture[0].length);
-				const parsed = parsers[i](capture, nestedParse, state);
-				advanceLookbehind(state, capture[0]);
-				if (!parsed.type) parsed.type = order[i];
-				result.push(parsed);
+		let hasContent = false;
+		for (let j = 0; j < source.length; j++) {
+			const c = source.charCodeAt(j);
+			if (c !== 32 && c !== 9 && c !== 10 && c !== 13) {
+				hasContent = true;
 				break;
 			}
 		}
+		if (hasContent) {
+			const asciiCandidates = isInline ? inlineAsciiCandidates : blockAsciiCandidates;
+			const defaultCandidates = isInline ? inlineDefaultCandidates : blockDefaultCandidates;
+			while (source) {
+				const code = source.charCodeAt(0);
+				const candidates = code < 128 ? asciiCandidates[code] : defaultCandidates;
+				const candidateCount = candidates.length;
+				let matched = false;
+				for (let c = 0; c < candidateCount; c++) {
+					const i = candidates[c];
+					const qualify = qualifiers[i];
+					if (qualify && !require_markdown_utils.qualifies(source, state, qualify)) continue;
+					const capture = matchers[i](source, state);
+					if (capture?.[0]) {
+						source = source.slice(capture[0].length);
+						const parsed = parsers[i](capture, nestedParse, state);
+						advanceLookbehind(state, capture[0]);
+						const nodeType = parsed.type || order[i];
+						parsed.type = nodeType;
+						const len = result.length;
+						if (nodeType === require_markdown_constants.RuleType.text) {
+							if (!parsed.text) {
+								matched = true;
+								break;
+							}
+							if (len > 0 && result[len - 1].type === require_markdown_constants.RuleType.text) {
+								result[len - 1].text += parsed.text;
+								matched = true;
+								break;
+							}
+						}
+						result.push(parsed);
+						matched = true;
+						break;
+					}
+				}
+				if (!matched) break;
+			}
+		}
 		return result;
 	};
 	return (source, state) => nestedParse(require_markdown_utils.normalizeWhitespace(source), state);

package/dist/cjs/markdown/parser.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parser.cjs","names":["qualifies","normalizeWhitespace"],"sources":["../../../src/markdown/parser.ts"],"sourcesContent":["import type {\n  NestedParser,\n  ParserResult,\n  ParseState,\n  Rule,\n  Rules,\n} from './types';\nimport { normalizeWhitespace, qualifies } from './utils';\n\n/**\n * Cached rule precedence, grouped by rule count.\n *\n * A rule's `_order` never varies, so the precedence a rule set sorts into is a\n * pure function of which rules it holds. Rules themselves are rebuilt per\n * document, so the cache is keyed by rule names rather than by object identity,\n * and grouped by count to keep the comparison short.\n */\ntype RuleOrderEntry = { names: string[]; order: string[] };\n\nconst ruleOrderCache = new Map<number, RuleOrderEntry[]>();\n\nconst sameNames = (a: string[], b: string[]): boolean => {\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n\n  return true;\n};\n\n/**\n * Resolves `Object.keys(rules)` into precedence order, sorting only the first\n * time a given rule set is seen.\n */\nconst orderRules = (names: string[], rules: Rules): string[] => {\n  const candidates = ruleOrderCache.get(names.length);\n\n  if (candidates) {\n    for (let i = 0; i < candidates.length; i++) {\n      if (sameNames(names, candidates[i]!.names)) return candidates[i]!.order;\n    }\n  }\n\n  // Sorts rules in order of increasing order, then\n  // ascending rule name (numeric) in case of ties.\n  // RuleType keys are string numbers — use numeric comparison to preserve\n  // intended ordering (e.g. codeFenced '4' must precede headingSetext '10').\n  const order = names\n    .slice()\n    .sort((a, b) => rules[a]!._order - rules[b]!._order || +a - +b);\n\n  const entry: RuleOrderEntry = { names: names.slice(), order };\n\n  if (candidates) candidates.push(entry);\n  else ruleOrderCache.set(names.length, [entry]);\n\n  return order;\n};\n\n/**\n * Advance the incremental lookbehind carried on the parse state.\n *\n * Rules only ever ask two questions about the source already consumed: how far\n * the current line is indented (`prevCaptureIndent`) and whether a blank line\n * has been seen (`prevCaptureHasBlankLine`). Both are maintained in time\n * proportional to the capture rather than by concatenating — and later\n * rescanning — the whole document, which made parsing quadratic.\n */\nconst advanceLookbehind = (state: ParseState, capture: string): void => {\n  const newlineIndex = capture.lastIndexOf('\\n');\n  // `undefined` marks a lookbehind nothing has been appended to yet, which is\n  // the only way to tell an empty lookbehind from one ending on a line break.\n  const hasPrevCapture = state.prevCaptureHasBlankLine !== undefined;\n\n  if (state.prevCaptureHasBlankLine !== true) {\n    state.prevCaptureHasBlankLine =\n      capture.indexOf('\\n\\n') !== -1 ||\n      // A capture opening on a line break closes a blank line when the\n      // lookbehind already ended on one.\n      (hasPrevCapture &&\n        capture.charCodeAt(0) === 10 /* \\n */ &&\n        state.prevCaptureIndent === '');\n  }\n\n  // Everything after the final newline forms the current line. With no newline\n  // in the capture, the current line simply grew by `capture`.\n  const tail =\n    newlineIndex === -1\n      ? state.prevCaptureIndent === undefined\n        ? undefined\n        : state.prevCaptureIndent + capture\n      : capture.slice(newlineIndex + 1);\n\n  if (tail === undefined || tail === '') {\n    state.prevCaptureIndent = tail;\n    return;\n  }\n\n  for (let i = 0; i < tail.length; i++) {\n    if (tail.charCodeAt(i) !== 32 /* space */) {\n      state.prevCaptureIndent = undefined;\n      return;\n    }\n  }\n\n  state.prevCaptureIndent = tail;\n};\n\n/**\n * Creates a parser for a given set of rules, with the precedence\n * specified as a list of rules.\n *\n * @param rules - An object containing rule type -> {match, order, parse} objects\n *                (lower order is higher precedence)\n *\n * @returns The resulting parse function\n */\nexport const parserFor = (\n  rules: Rules\n): ((source: string, state: ParseState) => ParserResult[]) => {\n  const ruleList = Object.keys(rules);\n\n  if (process.env.NODE_ENV !== 'production') {\n    ruleList.forEach((type) => {\n      const order = rules[type]?._order;\n      if (typeof order !== 'number' || !Number.isFinite(order)) {\n        console.warn(`intlayer: Invalid order for rule \\`${type}\\`: ${order}`);\n      }\n    });\n  }\n\n  const order = orderRules(ruleList, rules);\n  const ruleCount = order.length;\n\n  // Rule objects have heterogeneous shapes (`_qualify` and `_render` are both\n  // optional), so their members are hoisted into parallel arrays: the hot loop\n  // then reads monomorphic slots instead of polymorphic properties, and the\n  // whole set costs three allocations rather than one wrapper per rule.\n  const qualifiers: (Rule<any>['_qualify'] | undefined)[] = new Array(\n    ruleCount\n  );\n  const matchers: Rule<any>['_match'][] = new Array(ruleCount);\n  const parsers: Rule<any>['_parse'][] = new Array(ruleCount);\n\n  for (let i = 0; i < ruleCount; i++) {\n    const rule = rules[order[i]!]!;\n\n    qualifiers[i] = rule._qualify;\n    matchers[i] = rule._match;\n    parsers[i] = rule._parse;\n  }\n\n  const nestedParse: NestedParser = (\n    source: string,\n    state: ParseState = {}\n  ): ParserResult[] => {\n    const result: ParserResult[] = [];\n\n    if (state.prevCaptureHasBlankLine === undefined) {\n      // Nothing consumed yet: an empty lookbehind sits at the start of a line.\n      state.prevCaptureIndent = '';\n    }\n\n    if (source.trim()) {\n      while (source) {\n        for (let i = 0; i < ruleCount; i++) {\n          const qualify = qualifiers[i];\n\n          if (qualify && !qualifies(source, state, qualify)) continue;\n\n          const capture = matchers[i]!(source, state);\n\n          if (capture?.[0]) {\n            source = source.substring(capture[0].length);\n\n            const parsed: any = parsers[i]!(capture, nestedParse, state);\n\n            advanceLookbehind(state, capture[0]);\n\n            if (!parsed.type) {\n              parsed.type = order[i];\n            }\n\n            result.push(parsed as ParserResult);\n            break;\n          }\n        }\n      }\n    }\n\n    return result;\n  };\n\n  return (source: string, state: ParseState) =>\n    nestedParse(normalizeWhitespace(source), state);\n};\n"],"mappings":"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"}
+{"version":3,"file":"parser.cjs","names":["SCOPE_INLINE","SCOPE_BLOCK","qualifies","RuleType","normalizeWhitespace"],"sources":["../../../src/markdown/parser.ts"],"sourcesContent":["import { RuleType, SCOPE_BLOCK, SCOPE_INLINE } from './constants';\nimport type {\n  NestedParser,\n  ParserResult,\n  ParseState,\n  Rule,\n  Rules,\n} from './types';\nimport { normalizeWhitespace, qualifies } from './utils';\n\n/**\n * Advance the incremental lookbehind carried on the parse state.\n *\n * Rules only ever ask two questions about the source already consumed: how far\n * the current line is indented (`prevCaptureIndent`) and whether a blank line\n * has been seen (`prevCaptureHasBlankLine`). Both are maintained in time\n * proportional to the capture rather than by concatenating — and later\n * rescanning — the whole document, which made parsing quadratic.\n */\nconst advanceLookbehind = (state: ParseState, capture: string): void => {\n  const lastCode = capture.charCodeAt(capture.length - 1);\n\n  if (state.prevCaptureHasBlankLine !== true) {\n    state.prevCaptureHasBlankLine =\n      capture.indexOf('\\n\\n') !== -1 ||\n      (state.prevCaptureHasBlankLine !== undefined &&\n        capture.charCodeAt(0) === 10 &&\n        state.prevCaptureIndent === '');\n  }\n\n  // A capture whose last character is neither a space nor a newline cannot\n  // leave an all-space tail behind it, whatever it contains — so the common\n  // case never pays for the backwards `lastIndexOf` scan.\n  if (lastCode !== 32 /* space */ && lastCode !== 10 /* \\n */) {\n    state.prevCaptureIndent = undefined;\n    return;\n  }\n\n  const newlineIndex = capture.lastIndexOf('\\n');\n\n  const tail =\n    newlineIndex === -1\n      ? state.prevCaptureIndent === undefined\n        ? undefined\n        : state.prevCaptureIndent === ''\n          ? capture\n          : state.prevCaptureIndent + capture\n      : capture.slice(newlineIndex + 1);\n\n  if (tail === undefined || tail === '') {\n    state.prevCaptureIndent = tail;\n    return;\n  }\n\n  for (let i = 0; i < tail.length; i++) {\n    if (tail.charCodeAt(i) !== 32) {\n      state.prevCaptureIndent = undefined;\n      return;\n    }\n  }\n\n  state.prevCaptureIndent = tail;\n};\n\n/**\n * Creates a parser for a given set of rules, with the precedence\n * specified as a list of rules.\n */\nexport const parserFor = (\n  rules: Rules\n): ((source: string, state: ParseState) => ParserResult[]) => {\n  const order = Object.keys(rules).sort(\n    (a, b) => rules[a]!._order - rules[b]!._order || +a - +b\n  );\n  const ruleCount = order.length;\n\n  const qualifiers: (Rule<any>['_qualify'] | undefined)[] = new Array(\n    ruleCount\n  );\n  const matchers: Rule<any>['_match'][] = new Array(ruleCount);\n  const parsers: Rule<any>['_parse'][] = new Array(ruleCount);\n  const ruleFirstChars: (number[] | null)[] = new Array(ruleCount);\n  const ruleIsBlock: boolean[] = new Array(ruleCount);\n  const ruleIsInline: boolean[] = new Array(ruleCount);\n  const blockDefaultCandidates: number[] = [];\n  const inlineDefaultCandidates: number[] = [];\n\n  for (let i = 0; i < ruleCount; i++) {\n    const rule = rules[order[i]!]!;\n    let q = rule._qualify;\n    matchers[i] = rule._match;\n    parsers[i] = rule._parse;\n\n    const rawScope = rule._scope;\n    const isBlock = rawScope !== SCOPE_INLINE;\n    const isInline = rawScope !== SCOPE_BLOCK;\n\n    ruleIsBlock[i] = isBlock;\n    ruleIsInline[i] = isInline;\n\n    if (rule._firstChars && rule._firstChars.length > 0) {\n      ruleFirstChars[i] = rule._firstChars;\n    } else if (\n      Array.isArray(q) &&\n      q.length > 0 &&\n      q.every((p) => p.length > 0)\n    ) {\n      ruleFirstChars[i] = q.map((p) => p.charCodeAt(0));\n      if (q.every((p) => p.length === 1)) q = undefined;\n    } else {\n      ruleFirstChars[i] = null;\n      if (isBlock) blockDefaultCandidates.push(i);\n      if (isInline) inlineDefaultCandidates.push(i);\n    }\n    qualifiers[i] = q;\n  }\n\n  const blockAsciiCandidates: number[][] = new Array(128);\n  const inlineAsciiCandidates: number[][] = new Array(128);\n  for (let code = 0; code < 128; code++) {\n    const bList: number[] = [];\n    const iList: number[] = [];\n    for (let i = 0; i < ruleCount; i++) {\n      const isBlock = ruleIsBlock[i]!;\n      const isInline = ruleIsInline[i]!;\n      const chars = ruleFirstChars[i];\n\n      if (isBlock && (!chars || chars.includes(code))) {\n        bList.push(i);\n      }\n      if (isInline && (!chars || chars.includes(code))) {\n        iList.push(i);\n      }\n    }\n    blockAsciiCandidates[code] = bList;\n    inlineAsciiCandidates[code] = iList;\n  }\n\n  const nestedParse: NestedParser = (\n    source: string,\n    state: ParseState = {}\n  ): ParserResult[] => {\n    const result: ParserResult[] = [];\n    const isInline = Boolean(state.inline || state.simple);\n\n    if (state.prevCaptureHasBlankLine === undefined) {\n      state.prevCaptureIndent = '';\n    }\n\n    // Quick non-allocating whitespace check\n    let hasContent = false;\n    for (let j = 0; j < source.length; j++) {\n      const c = source.charCodeAt(j);\n      if (c !== 32 && c !== 9 && c !== 10 && c !== 13) {\n        hasContent = true;\n        break;\n      }\n    }\n\n    if (hasContent) {\n      const asciiCandidates = isInline\n        ? inlineAsciiCandidates\n        : blockAsciiCandidates;\n      const defaultCandidates = isInline\n        ? inlineDefaultCandidates\n        : blockDefaultCandidates;\n\n      while (source) {\n        const code = source.charCodeAt(0);\n        const candidates =\n          code < 128 ? asciiCandidates[code]! : defaultCandidates;\n        const candidateCount = candidates.length;\n        let matched = false;\n\n        for (let c = 0; c < candidateCount; c++) {\n          const i = candidates[c]!;\n          const qualify = qualifiers[i];\n\n          if (qualify && !qualifies(source, state, qualify)) continue;\n\n          const capture = matchers[i]!(source, state);\n\n          if (capture?.[0]) {\n            source = source.slice(capture[0].length);\n\n            const parsed: any = parsers[i]!(capture, nestedParse, state);\n\n            advanceLookbehind(state, capture[0]);\n\n            const nodeType = parsed.type || order[i];\n            parsed.type = nodeType;\n\n            const len = result.length;\n            if (nodeType === RuleType.text) {\n              if (!parsed.text) {\n                matched = true;\n                break;\n              }\n              if (len > 0 && result[len - 1]!.type === RuleType.text) {\n                (result[len - 1] as any).text += parsed.text;\n                matched = true;\n                break;\n              }\n            }\n\n            result.push(parsed as ParserResult);\n            matched = true;\n            break;\n          }\n        }\n\n        if (!matched) break;\n      }\n    }\n\n    return result;\n  };\n\n  return (source: string, state: ParseState) =>\n    nestedParse(normalizeWhitespace(source), state);\n};\n"],"mappings":"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"}

package/dist/cjs/markdown/renderer.cjs

@@ -15,10 +15,9 @@ const renderFor = (render) => {
 		let lastWasString = false;
 		let renderedIndex = 0;
 		for (let i = 0; i < ast.length; i++) {
-			const nodeOut = emit(ast[i], {
-				...state,
-				key: renderedIndex
-			});
+			state.key = renderedIndex;
+			const node = ast[i];
+			const nodeOut = Array.isArray(node) ? emit(node, state) : render(node, emit, state);
 			const isString = typeof nodeOut === "string";
 			if (isString && lastWasString) result[result.length - 1] = result[result.length - 1] + nodeOut;
 			else if (nodeOut !== null) {
@@ -34,14 +33,18 @@ const renderFor = (render) => {
 };
 /**
 * 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
 */
-const createRenderer = (rules, userRender) => (ast, render, state) => {
-	const renderer = rules[ast.type]?._render;
-	return userRender ? userRender(() => renderer?.(ast, render, state), ast, render, state) : renderer?.(ast, render, state);
+const createRenderer = (rules, userRender) => {
+	const renderers = {};
+	for (const type in rules) renderers[type] = rules[type]?._render;
+	if (!userRender) return (ast, render, state) => {
+		const r = renderers[ast.type];
+		return r ? r(ast, render, state) : void 0;
+	};
+	return (ast, render, state) => {
+		const renderer = renderers[ast.type];
+		return userRender(() => renderer?.(ast, render, state), ast, render, state);
+	};
 };
 
 //#endregion