v8 development

[quantizor]

Objectives

• allow for multiple rendering targets (react, solid, etc) punting this one to a future major so this can be released faster
• simplify text-handling regexes to optimize speed and complexity
• general codebase refactoring / profiling to remove bottlenecks
• potentially update the library name if we support rendering targets other than JSX punting this one to a future major so this can be released faster
• expose the parser so it can be used without directly compiling to a target
• custom rule support
• ability to disable/enable particular rules
• documentation

[changeset-bot]

🦋 Changeset detected

Latest commit: 4085815

The changes in this PR will be included in the next version bump.

This PR includes changesets to release 1 package

Name	Type
markdown-to-jsx	Major

Not sure what this means? Click here to learn what changesets are.

Click here if you're a maintainer who wants to add another changeset to this PR

To fix the problem, we need to refactor the regular expression to remove the ambiguity and nested quantifiers that cause exponential backtracking. This can be achieved by breaking down the regular expression into simpler, non-ambiguous parts and ensuring that each part matches a specific pattern without overlap.

In this case, we can refactor the regular expression to handle each part separately and avoid nested quantifiers. We will replace the problematic part with a more efficient pattern that achieves the same functionality.

To fix the problem, we need to modify the regular expression to remove the ambiguity that causes exponential backtracking. Specifically, we should replace the .*? pattern with a more specific pattern that avoids ambiguity. In this case, we can use a negated character class to match any character except the ones that would cause backtracking issues.

• Modify the regular expression on line 230 to replace .*? with a more specific pattern.
• Ensure that the new pattern maintains the existing functionality of the regular expression.

To fix the problem, we need to modify the regular expression to remove the ambiguity that causes exponential backtracking. Specifically, we should replace the .*? pattern with a more specific pattern that avoids the inefficiency.

• We will replace .*? with a pattern that matches any character except for the ones that could cause backtracking issues.
• The new pattern will be [^*<]*? which matches any character except * and <, thus preventing the problematic backtracking scenario.

To fix the problem, we need to modify the regular expression to remove the ambiguity that causes exponential backtracking. Specifically, we should replace the .*? pattern with a more precise pattern that avoids ambiguity. In this case, we can use a negated character class to match any character except the ones that would cause backtracking.

• Identify the problematic regular expression on line 230.
• Replace the .*? pattern with a negated character class that matches any character except the ones that would cause backtracking.
• Ensure that the new pattern maintains the original functionality of the regular expression.

To fix the problem, we need to modify the regular expression to remove the ambiguity that causes exponential backtracking. Specifically, we can replace .*? with a more specific pattern that avoids the inefficiency. In this case, we can use a negated character class to match any character except the ones that would cause backtracking issues.

• Replace .*? with a more specific pattern that avoids ambiguity and backtracking.
• Ensure the new pattern maintains the original functionality of the regular expression.

[quantizor]

Need to incorporate the changes from #594, #579