* Remove `greediness` property
Use boolean `grouped` property instead, which is more consistent with
LaTeX.
BREAKING CHANGE: \cfrac, \color, \textcolor, \colorbox, \fcolorbox are
no longer grouped.
* Rename grouped to allowedInArgument
* Reenable tests
* Update documentation
* Fix typo
Co-authored-by: Kevin Barabash <kevinb@khanacademy.org>
* Bump flow version
* Bump jest version
* Bump eslint version
* Bump rollup version
* Bump webpack version
* Bump misc dependencies and update lockfile
* Update lockfile
* Bump commander version
* Bump misc dependencies
* Bump istanbul version
* Bump docusaurus version
* Update lockfile
* Explicitly declare dependencies
* Bump caniuse-lite version
* Update lockfile
* Bump commander version
* Bump webpack and css-loader version
* Bump flow version
* Use babel-plugin-preval instead of own unicodeMake for unicodeSymbols
* Fix circular dependency transpiling issue
* Flow type unicodeSymbols.js
Co-authored-by: Erik Demaine <edemaine@mit.edu>
* Add parseNode type `internal`
* Move \def and \newcommand to functions
* Fix Flow error
* Separate \global
Move \newcommand back to macros for now
* Rename assignment.js to def.js
* Update test cases
* Add comments
* Update a test case
We used functions with $FlowFixMe as Flow couldn't refine ParseNode
using its type. It seems the issue has been fixed and complicated
function calls can be removed.
2019-11-29 15:08:22 -05:00
Ciro Santilli，Opinions and content are my own, not my employer's，2018新疆改造中心，1989六四事件，1999法轮功 ，2019 996.ICU, 2018包子露宪，2015 710律师劫，2015巴拿马文件 邓家贵，2017低端人口，2008西藏骚乱scriptalert(1)/script
* Fix parse timing by separating consume() into fetch() and consume()
Fix#1989, and generally cleanup parse timing (many fewer hoops to jump
through) by defining two methods on parser:
1. `consume()` marks the current token (`nextToken`) as "done", but
doesn't yet fetch the next token (setting `nextToken` to `null`).
2. `fetch()` fetches the next token if we don't already have one
(e.g., if last token was `consume()`d).
Before this change, `consume()` did both actions. By separating them,
and allowing the parser to live in a state for a while where `nextToken`
is `null`, it is far easier to change settings (in particular, math/text
mode and catcodes) before reading the next token, in a way that depends
on what we're parsing. For example, if an argument should be treated in
text mode, we can just set the mode in the argument parser, instead of
when the previous token was consumed. Similarly, if an argument should
be treated as a URL, we can just set the catcode of `%` in the URL
argument parser, and reset it after. We no longer have to take care to
reset things before calling `consume()`.
This change mostly involves changing `this.nextToken` to `this.fetch()`.
In a perfect world, we could use slightly fewer calls to `this.fetch()`,
but Flow doesn't realize that `this.nextToken` will be non-null after a
call to `this.fetch()`, so we need to use a few more calls to
`this.nextToken()` or a few more local `nextToken` variables.
* Remove now-unnecessary consumeMath
* Update Parser.js
* Unicode characters in math render in text mode
Improve #2031 by rendering all supported Unicode text characters (via
supportedCodepoints) in text mode, mimicking wrapping them in `\text`,
thereby using metrics of letter M as usual.
* Add tests
* Improve documentation
* Implement review comments
* Remove forced \normalsize in \raisebox
Fix#1786 (incorrect size of "E" in `\TeX`) by fixing `\raisebox` to
keep the current font size. Previously, `\raisebox` was rendering its
second argument as if it were in `\normalsize\textrm{...}`; now,
the argument is just as if it were in `\textrm{...}`.
* Fix screenshots
* New "hbox" argument type to convert box-like arguments
* Review comments
* Fix \fbox to use hbox argument
* Render A in \LaTeX and \KaTeX in \scriptstyle (not \scriptsize)
* Add screenshot test
* Revert .sizing { width: min-content} thanks to #2044
* trust option to indicate whether input text is trusted
* Revamp into trust contexts beyond just command
* Document new trust function style
* Fix screenshot testing
* Use trust setting in \url and \href
* Check `isTrusted` in `\url` and `\href` (so now disabled by default)
* Automatically compute `protocol` from `url` in `isTrusted`, so it
doesn't need to be passed into every context.
* Document untrusted features in support list/table
* Existing tests trust by default
* remove allowedProtocols and fix flow errors
* remove 'allowedProtocols' from documentation
* add a comment about a flow error, rename urlToProtocol to protocolFromUrl
* add tests test that use function version of trust option
* default trust to false in MathML tests
* fix test title, remove 'trust: false' from test settings since it's the default
* Remove redundant consumeSpaces()
- Spaces after command sequence are ignored in Lexer
- parseExpression consumes spaces in the math mode
* Add catcode to Lexer, move comment parsing back to Lexer
- Fix parsing a comment before a sup/subscript argument
- Fix parsing a comment before an expression
- Fix parsing a comment before or between \hline
- Fix parsing a comment in the macro definition
- Fix parsing a comment including a command sequence
* Update Lexer.js
* Update Parser.js
* catcode -> catcodes
* Move unsupported command (undefined control sequence) error to parseSymbol
* Change parseGivenFunction and parseFunction to parse only function
* Move \begin handling to environment.js
* Remove ParsedFunc/Arg, move logics into parseGroup
* Fix flow error
* Remove parseFunction, rename parseGivenFunction to parseFunction
* Minor fixes
* Remove previously resolved TODO
* Minor fixes
* Update flow typing
* Update comment for defineFunction handler.
* Rename .value to .text in all token-style ParseNodes.
* Rename symbolNode's .value to .text.
* Rename color-token's .value to .color.
* Define the nested version of ParseNodes structs explicitly.
Passes test:jest, but fails test:flow.
* Fix additional type errors reported by flow.
* Migrate rebased code from master.
* Rename ParseNode.js to parseNode.js.
* Update defineEnvironment output type to fix the flow errors in environment/array.js.
* Comments without terminating newlines in nonstrict mode
Fix#1506 by allowing single-line comments (`%` without terminating newline)
in nonstrict mode. `Lexer` and `MacroExpander` now store the `Settings`
object, so the `Lexer` can complain about missing newline according to the
`strict` setting. I filtered this out from the snapshot tests with a slightly
different `replacer`.
* Reimplement \href like \verb, add \url
Major restructuring to lex URL arguments differently, e.g. to support
`\href%{hello}` and `\href{http://foo.com/#test%}{hello}`. The new URL
parsing code is simpler, but involves a special case in `parseSymbol`
like `\verb`.
Also add support for `\url` while we're here.
* Cleanup
* Fix flow errors and improve error messages
* Add \url to documentation
* Improve doc formatting
* \html@mathml
Fix#1452
* Add missing file
* Implement \char (via internal \@char)
* Remove excess <mstyle> wrapper on \mathbin etc.
* Fix tests
* Add Unicode support for \copyright and \textregistered
Testing that this doesn't lead to an infinite loop thanks to \char` escaping.
* Add tests
* Use assertNodeType
* Switch from regex to lookup table, and no parseInt
* Support \genfrac and \above
* Accommodate delimiters inside groups
* Update screenshots take one`
* Update screenshots take two
* Fix flow error
* Fix lint error
* Fix ligatures not always triggering
Example: \text{\rm --} would not cause ligature but should
* Remove ligatures in \texttt mode
* Add screenshot tests
* Fix MathML ligatures
* Fix type
* Handle \text... fonts in MathML building
* Remove leftover console deubgging
* Replace ParseNode<*> with a more accurate AnyParseNode and fix flow errors.
* Allow "array" environment type spec to use any all symbol type.
Before this commit, it was constrained to use "mathord" and "textord", but a
recent change in HEAD resulted in a "rel" node being used in the spec for, e.g.
\begin{array}{|l||c:r::}\end{array}
* Address reviewer comments: rename `lastRow` to `row` in array.js.
* Nested environments of macro definitions
* Rename environment -> namespace
* \def support
* Clean up \df@tag at beginning
* \global\def support
* Fix \global via new setMacro helper
* Fix caching behavior and build array on top of it
Also avoid double lookup of macros
* Add tests
* Add argument tests
* Remove global pointer
* Note about macros object being modified
* add __defineMacro
* Add \global\def test
* More \global tests
* Constant-time lookup
Rewrite to use an "undo" stack similar to TeX, so get and set are
constant-time operations. get() still has to check two objects: one with all
current settings, and then the built-ins. Local set() sets the current value
and (when appropriate) adds an undo operation to the undo stack. Global set()
still takes time linear in the number of groups, possibly changing the undo
operation at every level.
`Namespace` now refers to a space of things like macros or lengths.
* Add \def to-dos
* Put optional arguments in their own group
* Rename `pushNamespace` -> `beginGroup`
* Wrap each expression in a group namespace
* Add comments
* Tag sketch
* Drop objectAssign; already using Object.assign elsewhere
* Basic \gdef support
* Bug fix
* Finish \tag
* MathML numbers equations with <mlabeledtr>
* Fix flow bugs
* \gdef tests
* Add basic \tag tests
* Screenshot test for \tag
* \tag* test
* Add missing file
* Bug fix screenshot
* Major refactor
* Represent tag at top level of parse tree, requiring less hackery
* No more \@tag function; it was essentially just doing \text
* Wrap tag in group so e.g. ( and ) are formatted the same
* Add `feed` method to MacroExpander for multiple inputs (for tag)
* Bug fixes in buildHTML, makeTextRow, _getBuilt (for display mode)
* Remove excess <mrow> wrapper when unnecessary
* Update screenshot from tag being wrapped in group
* Add maxExpand limit
Change symbol parsing to allow all Unicode symbols when the appropriate strict setting allows it. By default, this allows all symbols, but the user will get (probably two) warnings about them.
* Strict setting controls \newline display-mode behavior
* Bug-fix space handling in macros
Whitespace after a \controlWord is now handled within the lexer, not by the
MacroExpander. This way, \\ expanding to \newline doesn't accidentally
cause spaces to get consumed.
* Rename nonstrict -> reportNonstrict; strictBehavior -> useStrictBehavior
* Second category of errorCodes
* Implement strict mode (replacing unicodeTextInMathMode)
Add new "strict" setting (default value false) that can take a boolean
(whether to throw an error or silently ignore), string ("ignore",
"warn", or "error"), or a function possibly returning such a value.
This enables a variety of ways of handling or ignoring transgressions
from "true" LaTeX behavior, making KaTeX easier to use while still
providing the ability for strict LaTeX adherance.
Resolve#1226, implementing that spec, for two existing
transgressions from regular LaTeX:
* src/functions/kern.js had some errors and warnings about use of
(units in) math vs. text mode commands.
* The former setting unicodeTextInMathMode (not in any released version)
needed to be set to true to enable Unicode text symbols in math mode.
Now these are controlled by the strict setting. By default, KaTeX is now
very permissive, but if desired, the user can request warnings or errors.
* Rewrite strict description
* Add tests for strict functions
* Stricter type for strict
* Switch default strict setting to "warn"
* Fix new flow error
* Fix another flow bug
* Support for top-level \newline and \\ in inline math
This was a little tricky because `\\` was defined as an endOfExpression.
Instead made `\\` a termination specific to an array environment.
Outside an array environment, buildHTML handles the `cr` object,
resulting in a `.newline` class. Currently this turns into a
`display: block` (with appropriate vertical spacing) only in inline math,
matching LaTeX.
* Simplify code
* Fix Jest errors
* NewLine screenshot test
* Bug fix: \\ only works at top level of inline
* Add \newline and \cr to test
* Switch test to pmatrix
* Add vertical space test
* Add \\ vs. \newline tests
* Fix flow errors
* Add \cr test
* Add documentation for \\ at top level
* Comment out newRow
* Fix commenting out
* Make ParseNode `value` payload type-safe.
* Make defineFunction handlers aware of ParseNode data types.
* Add `type` to all function definitions to help determine handler return type.
* Added unit test for case caught only in screenshot test and fixed issue.
* Rename some symbol `Group`s to avoid conflicts with `ParseNode` groups.
Symbol `Group`s are also used as `ParseNode` types. However, `ParseNode`s of
these types always contain a raw text token as opposed to any structured
content. These `ParseNode`s are passed as arguments into function handlers to
create more semantical `ParseNode`s with more structure.
Before this change, "accent" and "op" were both symbol `Group`s and `ParseNode`
types. With this change, these two types (the raw accent token `ParseNode`, and
the structured semantical `ParseNode` are separated for better type-safety on
the `ParseNode` payload).
* stretchy: Remove FlowFixMe for a forced typecast that's no longer needed.
* Fix#1212 by supporting `\(...\)` in addition to `$...$` inline math nested inside `\text`. This turned out to be harder than one would think because of the way `$` was being handled specially, while `\(` needed to be handled as a function, which immediately consumed the `\(` token, which meant that the first following token got consumed in text mode instead of math mode (unlike `$` where we could switch the mode before consumption).
* Added new `consumeMode` setting for functions which tells the parser to switch modes just for the consumption of the command token.
* Now that we're working with functions, move all the `$` handling code into `functions/math.js`. Somewhat bizarrely, we can define `$` as a function (nearly identical to `\(`) and it all works (just like we can have single-character macros). This move removed a lot of messy stuff from `Parser.js`: `ParsedDollar`, `ParsedFuncOrArgOrDollar`, `newDollar`, `assertFuncOrArg`, and at least three explicit checks for `if (... === "$")`.
* Moved the `consume()` for the command token from `parseSymbol` to `parseGivenFunction`. This ended up not being strictly necessary, but seems conceptually cleaner.
* Partially address #1027 by setting `consumeMode: "text"` for `\text` commands. As a result, `\text` now instantly switches the mode to `"text"`, so even an unbraced macro argument will properly detect text mode. I added a test for this, which is a slightly weaker form of #1027.
* unicodeTextInMathMode setting
* When `unicodeTextInMathMode` is `true`, accented letters from
`unicodeSymbols.js`, and CJK and other supported languages,
get added support in math mode (as requested in #895).
* When `unicodeTextInMathMode` is `false, all of these stop working in
math mode, and are only supported in text mode (matching XeTeX behavior).
Note that this is a backwards incompatibility with some 0.9.0 alpha/betas.
* Fix handling of Unicode characters ð, Å, å
* Fix double handling of ð (math maps to \eth, not special Unicode character)
* Remove Åå special math handling, thanks to #1125
* Forbid extraLatin when unicodeTextInMathMode is false
