diff --git a/tools/ui/node_modules/recast/lib/mapping.js b/tools/ui/node_modules/recast/lib/mapping.js new file mode 100644 index 0000000000000000000000000000000000000000..002d4ca64688f25eb7a68b05974ea7e299c6c794 --- /dev/null +++ b/tools/ui/node_modules/recast/lib/mapping.js @@ -0,0 +1,197 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var tslib_1 = require("tslib"); +var tiny_invariant_1 = tslib_1.__importDefault(require("tiny-invariant")); +var util_1 = require("./util"); +var Mapping = /** @class */ (function () { + function Mapping(sourceLines, sourceLoc, targetLoc) { + if (targetLoc === void 0) { targetLoc = sourceLoc; } + this.sourceLines = sourceLines; + this.sourceLoc = sourceLoc; + this.targetLoc = targetLoc; + } + Mapping.prototype.slice = function (lines, start, end) { + if (end === void 0) { end = lines.lastPos(); } + var sourceLines = this.sourceLines; + var sourceLoc = this.sourceLoc; + var targetLoc = this.targetLoc; + function skip(name) { + var sourceFromPos = sourceLoc[name]; + var targetFromPos = targetLoc[name]; + var targetToPos = start; + if (name === "end") { + targetToPos = end; + } + else { + (0, tiny_invariant_1.default)(name === "start"); + } + return skipChars(sourceLines, sourceFromPos, lines, targetFromPos, targetToPos); + } + if ((0, util_1.comparePos)(start, targetLoc.start) <= 0) { + if ((0, util_1.comparePos)(targetLoc.end, end) <= 0) { + targetLoc = { + start: subtractPos(targetLoc.start, start.line, start.column), + end: subtractPos(targetLoc.end, start.line, start.column), + }; + // The sourceLoc can stay the same because the contents of the + // targetLoc have not changed. + } + else if ((0, util_1.comparePos)(end, targetLoc.start) <= 0) { + return null; + } + else { + sourceLoc = { + start: sourceLoc.start, + end: skip("end"), + }; + targetLoc = { + start: subtractPos(targetLoc.start, start.line, start.column), + end: subtractPos(end, start.line, start.column), + }; + } + } + else { + if ((0, util_1.comparePos)(targetLoc.end, start) <= 0) { + return null; + } + if ((0, util_1.comparePos)(targetLoc.end, end) <= 0) { + sourceLoc = { + start: skip("start"), + end: sourceLoc.end, + }; + targetLoc = { + // Same as subtractPos(start, start.line, start.column): + start: { line: 1, column: 0 }, + end: subtractPos(targetLoc.end, start.line, start.column), + }; + } + else { + sourceLoc = { + start: skip("start"), + end: skip("end"), + }; + targetLoc = { + // Same as subtractPos(start, start.line, start.column): + start: { line: 1, column: 0 }, + end: subtractPos(end, start.line, start.column), + }; + } + } + return new Mapping(this.sourceLines, sourceLoc, targetLoc); + }; + Mapping.prototype.add = function (line, column) { + return new Mapping(this.sourceLines, this.sourceLoc, { + start: addPos(this.targetLoc.start, line, column), + end: addPos(this.targetLoc.end, line, column), + }); + }; + Mapping.prototype.subtract = function (line, column) { + return new Mapping(this.sourceLines, this.sourceLoc, { + start: subtractPos(this.targetLoc.start, line, column), + end: subtractPos(this.targetLoc.end, line, column), + }); + }; + Mapping.prototype.indent = function (by, skipFirstLine, noNegativeColumns) { + if (skipFirstLine === void 0) { skipFirstLine = false; } + if (noNegativeColumns === void 0) { noNegativeColumns = false; } + if (by === 0) { + return this; + } + var targetLoc = this.targetLoc; + var startLine = targetLoc.start.line; + var endLine = targetLoc.end.line; + if (skipFirstLine && startLine === 1 && endLine === 1) { + return this; + } + targetLoc = { + start: targetLoc.start, + end: targetLoc.end, + }; + if (!skipFirstLine || startLine > 1) { + var startColumn = targetLoc.start.column + by; + targetLoc.start = { + line: startLine, + column: noNegativeColumns ? Math.max(0, startColumn) : startColumn, + }; + } + if (!skipFirstLine || endLine > 1) { + var endColumn = targetLoc.end.column + by; + targetLoc.end = { + line: endLine, + column: noNegativeColumns ? Math.max(0, endColumn) : endColumn, + }; + } + return new Mapping(this.sourceLines, this.sourceLoc, targetLoc); + }; + return Mapping; +}()); +exports.default = Mapping; +function addPos(toPos, line, column) { + return { + line: toPos.line + line - 1, + column: toPos.line === 1 ? toPos.column + column : toPos.column, + }; +} +function subtractPos(fromPos, line, column) { + return { + line: fromPos.line - line + 1, + column: fromPos.line === line ? fromPos.column - column : fromPos.column, + }; +} +function skipChars(sourceLines, sourceFromPos, targetLines, targetFromPos, targetToPos) { + var targetComparison = (0, util_1.comparePos)(targetFromPos, targetToPos); + if (targetComparison === 0) { + // Trivial case: no characters to skip. + return sourceFromPos; + } + var sourceCursor, targetCursor; + if (targetComparison < 0) { + // Skipping forward. + sourceCursor = + sourceLines.skipSpaces(sourceFromPos) || sourceLines.lastPos(); + targetCursor = + targetLines.skipSpaces(targetFromPos) || targetLines.lastPos(); + var lineDiff = targetToPos.line - targetCursor.line; + sourceCursor.line += lineDiff; + targetCursor.line += lineDiff; + if (lineDiff > 0) { + // If jumping to later lines, reset columns to the beginnings + // of those lines. + sourceCursor.column = 0; + targetCursor.column = 0; + } + else { + (0, tiny_invariant_1.default)(lineDiff === 0); + } + while ((0, util_1.comparePos)(targetCursor, targetToPos) < 0 && + targetLines.nextPos(targetCursor, true)) { + (0, tiny_invariant_1.default)(sourceLines.nextPos(sourceCursor, true)); + (0, tiny_invariant_1.default)(sourceLines.charAt(sourceCursor) === targetLines.charAt(targetCursor)); + } + } + else { + // Skipping backward. + sourceCursor = + sourceLines.skipSpaces(sourceFromPos, true) || sourceLines.firstPos(); + targetCursor = + targetLines.skipSpaces(targetFromPos, true) || targetLines.firstPos(); + var lineDiff = targetToPos.line - targetCursor.line; + sourceCursor.line += lineDiff; + targetCursor.line += lineDiff; + if (lineDiff < 0) { + // If jumping to earlier lines, reset columns to the ends of + // those lines. + sourceCursor.column = sourceLines.getLineLength(sourceCursor.line); + targetCursor.column = targetLines.getLineLength(targetCursor.line); + } + else { + (0, tiny_invariant_1.default)(lineDiff === 0); + } + while ((0, util_1.comparePos)(targetToPos, targetCursor) < 0 && + targetLines.prevPos(targetCursor, true)) { + (0, tiny_invariant_1.default)(sourceLines.prevPos(sourceCursor, true)); + (0, tiny_invariant_1.default)(sourceLines.charAt(sourceCursor) === targetLines.charAt(targetCursor)); + } + } + return sourceCursor; +} diff --git a/tools/ui/node_modules/recast/lib/options.d.ts b/tools/ui/node_modules/recast/lib/options.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..61488a9cc9721eaedf289ccdfb4a762d4df0aa18 --- /dev/null +++ b/tools/ui/node_modules/recast/lib/options.d.ts @@ -0,0 +1,147 @@ +/** + * All Recast API functions take second parameter with configuration options, + * documented in options.js + */ +export interface Options extends DeprecatedOptions { + /** + * If you want to use a different branch of esprima, or any other module + * that supports a .parse function, pass that module object to + * recast.parse as options.parser (legacy synonym: options.esprima). + * @default require("recast/parsers/esprima") + */ + parser?: any; + /** + * Number of spaces the pretty-printer should use per tab for + * indentation. If you do not pass this option explicitly, it will be + * (quite reliably!) inferred from the original code. + * @default 4 + */ + tabWidth?: number; + /** + * If you really want the pretty-printer to use tabs instead of spaces, + * make this option true. + * @default false + */ + useTabs?: boolean; + /** + * The reprinting code leaves leading whitespace untouched unless it has + * to reindent a line, or you pass false for this option. + * @default true + */ + reuseWhitespace?: boolean; + /** + * Override this option to use a different line terminator, e.g. \r\n. + * @default require("os").EOL || "\n" + */ + lineTerminator?: string; + /** + * Some of the pretty-printer code (such as that for printing function + * parameter lists) makes a valiant attempt to prevent really long + * lines. You can adjust the limit by changing this option; however, + * there is no guarantee that line length will fit inside this limit. + * @default 74 + */ + wrapColumn?: number; + /** + * Pass a string as options.sourceFileName to recast.parse to tell the + * reprinter to keep track of reused code so that it can construct a + * source map automatically. + * @default null + */ + sourceFileName?: string | null; + /** + * Pass a string as options.sourceMapName to recast.print, and (provided + * you passed options.sourceFileName earlier) the PrintResult of + * recast.print will have a .map property for the generated source map. + * @default null + */ + sourceMapName?: string | null; + /** + * If provided, this option will be passed along to the source map + * generator as a root directory for relative source file paths. + * @default null + */ + sourceRoot?: string | null; + /** + * If you provide a source map that was generated from a previous call + * to recast.print as options.inputSourceMap, the old source map will be + * composed with the new source map. + * @default null + */ + inputSourceMap?: string | null; + /** + * If you want esprima to generate .range information (recast only uses + * .loc internally), pass true for this option. + * @default false + */ + range?: boolean; + /** + * If you want esprima not to throw exceptions when it encounters + * non-fatal errors, keep this option true. + * @default true + */ + tolerant?: boolean; + /** + * If you want to override the quotes used in string literals, specify + * either "single", "double", or "auto" here ("auto" will select the one + * which results in the shorter literal) Otherwise, use double quotes. + * @default null + */ + quote?: "single" | "double" | "auto" | null; + /** + * Controls the printing of trailing commas in object literals, array + * expressions and function parameters. + * + * This option could either be: + * * Boolean - enable/disable in all contexts (objects, arrays and function params). + * * Object - enable/disable per context. + * + * Example: + * trailingComma: { + * objects: true, + * arrays: true, + * parameters: false, + * } + * + * @default false + */ + trailingComma?: boolean; + /** + * Controls the printing of spaces inside array brackets. + * See: http://eslint.org/docs/rules/array-bracket-spacing + * @default false + */ + arrayBracketSpacing?: boolean; + /** + * Controls the printing of spaces inside object literals, + * destructuring assignments, and import/export specifiers. + * See: http://eslint.org/docs/rules/object-curly-spacing + * @default true + */ + objectCurlySpacing?: boolean; + /** + * If you want parenthesis to wrap single-argument arrow function + * parameter lists, pass true for this option. + * @default false + */ + arrowParensAlways?: boolean; + /** + * There are 2 supported syntaxes (`,` and `;`) in Flow Object Types; + * The use of commas is in line with the more popular style and matches + * how objects are defined in JS, making it a bit more natural to write. + * @default true + */ + flowObjectCommas?: boolean; + /** + * Whether to return an array of .tokens on the root AST node. + * @default true + */ + tokens?: boolean; +} +interface DeprecatedOptions { + /** @deprecated */ + esprima?: any; +} +export type NormalizedOptions = Required>; +export declare function normalize(opts?: Options): NormalizedOptions; +export {}; diff --git a/tools/ui/node_modules/recast/lib/options.js b/tools/ui/node_modules/recast/lib/options.js new file mode 100644 index 0000000000000000000000000000000000000000..3ba2b45a8fdfea8b560eb30f0847e59e23280492 --- /dev/null +++ b/tools/ui/node_modules/recast/lib/options.js @@ -0,0 +1,55 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.normalize = void 0; +var util_1 = require("./util"); +var defaults = { + parser: require("../parsers/esprima"), + tabWidth: 4, + useTabs: false, + reuseWhitespace: true, + lineTerminator: (0, util_1.getLineTerminator)(), + wrapColumn: 74, + sourceFileName: null, + sourceMapName: null, + sourceRoot: null, + inputSourceMap: null, + range: false, + tolerant: true, + quote: null, + trailingComma: false, + arrayBracketSpacing: false, + objectCurlySpacing: true, + arrowParensAlways: false, + flowObjectCommas: true, + tokens: true, +}; +var hasOwn = defaults.hasOwnProperty; +// Copy options and fill in default values. +function normalize(opts) { + var options = opts || defaults; + function get(key) { + return hasOwn.call(options, key) ? options[key] : defaults[key]; + } + return { + tabWidth: +get("tabWidth"), + useTabs: !!get("useTabs"), + reuseWhitespace: !!get("reuseWhitespace"), + lineTerminator: get("lineTerminator"), + wrapColumn: Math.max(get("wrapColumn"), 0), + sourceFileName: get("sourceFileName"), + sourceMapName: get("sourceMapName"), + sourceRoot: get("sourceRoot"), + inputSourceMap: get("inputSourceMap"), + parser: get("esprima") || get("parser"), + range: get("range"), + tolerant: get("tolerant"), + quote: get("quote"), + trailingComma: get("trailingComma"), + arrayBracketSpacing: get("arrayBracketSpacing"), + objectCurlySpacing: get("objectCurlySpacing"), + arrowParensAlways: get("arrowParensAlways"), + flowObjectCommas: get("flowObjectCommas"), + tokens: !!get("tokens"), + }; +} +exports.normalize = normalize; diff --git a/tools/ui/node_modules/recast/lib/parser.d.ts b/tools/ui/node_modules/recast/lib/parser.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6f1d6df3302b7696eff62696dc64d02909421e38 --- /dev/null +++ b/tools/ui/node_modules/recast/lib/parser.d.ts @@ -0,0 +1,2 @@ +import { Options } from "./options"; +export declare function parse(source: string, options?: Partial): any; diff --git a/tools/ui/node_modules/recast/lib/parser.js b/tools/ui/node_modules/recast/lib/parser.js new file mode 100644 index 0000000000000000000000000000000000000000..df257f8bc26d28045e0487f76443eaf4224d63bc --- /dev/null +++ b/tools/ui/node_modules/recast/lib/parser.js @@ -0,0 +1,250 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parse = void 0; +var tslib_1 = require("tslib"); +var tiny_invariant_1 = tslib_1.__importDefault(require("tiny-invariant")); +var types = tslib_1.__importStar(require("ast-types")); +var b = types.builders; +var isObject = types.builtInTypes.object; +var isArray = types.builtInTypes.array; +var options_1 = require("./options"); +var lines_1 = require("./lines"); +var comments_1 = require("./comments"); +var util = tslib_1.__importStar(require("./util")); +function parse(source, options) { + options = (0, options_1.normalize)(options); + var lines = (0, lines_1.fromString)(source, options); + var sourceWithoutTabs = lines.toString({ + tabWidth: options.tabWidth, + reuseWhitespace: false, + useTabs: false, + }); + var comments = []; + var ast = options.parser.parse(sourceWithoutTabs, { + jsx: true, + loc: true, + locations: true, + range: options.range, + comment: true, + onComment: comments, + tolerant: util.getOption(options, "tolerant", true), + ecmaVersion: 6, + sourceType: util.getOption(options, "sourceType", "module"), + }); + // Use ast.tokens if possible, and otherwise fall back to the Esprima + // tokenizer. All the preconfigured ../parsers/* expose ast.tokens + // automatically, but custom parsers might need additional configuration + // to avoid this fallback. + var tokens = Array.isArray(ast.tokens) + ? ast.tokens + : require("esprima").tokenize(sourceWithoutTabs, { + loc: true, + }); + // We will reattach the tokens array to the file object below. + delete ast.tokens; + // Make sure every token has a token.value string. + tokens.forEach(function (token) { + if (typeof token.value !== "string") { + token.value = lines.sliceString(token.loc.start, token.loc.end); + } + }); + if (Array.isArray(ast.comments)) { + comments = ast.comments; + delete ast.comments; + } + if (ast.loc) { + // If the source was empty, some parsers give loc.{start,end}.line + // values of 0, instead of the minimum of 1. + util.fixFaultyLocations(ast, lines); + } + else { + ast.loc = { + start: lines.firstPos(), + end: lines.lastPos(), + }; + } + ast.loc.lines = lines; + ast.loc.indent = 0; + var file; + var program; + if (ast.type === "Program") { + program = ast; + // In order to ensure we reprint leading and trailing program + // comments, wrap the original Program node with a File node. Only + // ESTree parsers (Acorn and Esprima) return a Program as the root AST + // node. Most other (Babylon-like) parsers return a File. + file = b.file(ast, options.sourceFileName || null); + file.loc = { + start: lines.firstPos(), + end: lines.lastPos(), + lines: lines, + indent: 0, + }; + } + else if (ast.type === "File") { + file = ast; + program = file.program; + } + // Expose file.tokens unless the caller passed false for options.tokens. + if (options.tokens) { + file.tokens = tokens; + } + // Expand the Program's .loc to include all comments (not just those + // attached to the Program node, as its children may have comments as + // well), since sometimes program.loc.{start,end} will coincide with the + // .loc.{start,end} of the first and last *statements*, mistakenly + // excluding comments that fall outside that region. + var trueProgramLoc = util.getTrueLoc({ + type: program.type, + loc: program.loc, + body: [], + comments: comments, + }, lines); + program.loc.start = trueProgramLoc.start; + program.loc.end = trueProgramLoc.end; + // Passing file.program here instead of just file means that initial + // comments will be attached to program.body[0] instead of program. + (0, comments_1.attach)(comments, program.body.length ? file.program : file, lines); + // Return a copy of the original AST so that any changes made may be + // compared to the original. + return new TreeCopier(lines, tokens).copy(file); +} +exports.parse = parse; +var TreeCopier = function TreeCopier(lines, tokens) { + (0, tiny_invariant_1.default)(this instanceof TreeCopier); + this.lines = lines; + this.tokens = tokens; + this.startTokenIndex = 0; + this.endTokenIndex = tokens.length; + this.indent = 0; + this.seen = new Map(); +}; +var TCp = TreeCopier.prototype; +TCp.copy = function (node) { + if (this.seen.has(node)) { + return this.seen.get(node); + } + if (isArray.check(node)) { + var copy_1 = new Array(node.length); + this.seen.set(node, copy_1); + node.forEach(function (item, i) { + copy_1[i] = this.copy(item); + }, this); + return copy_1; + } + if (!isObject.check(node)) { + return node; + } + util.fixFaultyLocations(node, this.lines); + var copy = Object.create(Object.getPrototypeOf(node), { + original: { + // Provide a link from the copy to the original. + value: node, + configurable: false, + enumerable: false, + writable: true, + }, + }); + this.seen.set(node, copy); + var loc = node.loc; + var oldIndent = this.indent; + var newIndent = oldIndent; + var oldStartTokenIndex = this.startTokenIndex; + var oldEndTokenIndex = this.endTokenIndex; + if (loc) { + // When node is a comment, we set node.loc.indent to + // node.loc.start.column so that, when/if we print the comment by + // itself, we can strip that much whitespace from the left margin of + // the comment. This only really matters for multiline Block comments, + // but it doesn't hurt for Line comments. + if (node.type === "Block" || + node.type === "Line" || + node.type === "CommentBlock" || + node.type === "CommentLine" || + this.lines.isPrecededOnlyByWhitespace(loc.start)) { + newIndent = this.indent = loc.start.column; + } + // Every node.loc has a reference to the original source lines as well + // as a complete list of source tokens. + loc.lines = this.lines; + loc.tokens = this.tokens; + loc.indent = newIndent; + // Set loc.start.token and loc.end.token such that + // loc.tokens.slice(loc.start.token, loc.end.token) returns a list of + // all the tokens that make up this node. + this.findTokenRange(loc); + } + var keys = Object.keys(node); + var keyCount = keys.length; + for (var i = 0; i < keyCount; ++i) { + var key = keys[i]; + if (key === "loc") { + copy[key] = node[key]; + } + else if (key === "tokens" && node.type === "File") { + // Preserve file.tokens (uncopied) in case client code cares about + // it, even though Recast ignores it when reprinting. + copy[key] = node[key]; + } + else { + copy[key] = this.copy(node[key]); + } + } + this.indent = oldIndent; + this.startTokenIndex = oldStartTokenIndex; + this.endTokenIndex = oldEndTokenIndex; + return copy; +}; +// If we didn't have any idea where in loc.tokens to look for tokens +// contained by this loc, a binary search would be appropriate, but +// because we maintain this.startTokenIndex and this.endTokenIndex as we +// traverse the AST, we only need to make small (linear) adjustments to +// those indexes with each recursive iteration. +TCp.findTokenRange = function (loc) { + // In the unlikely event that loc.tokens[this.startTokenIndex] starts + // *after* loc.start, we need to rewind this.startTokenIndex first. + while (this.startTokenIndex > 0) { + var token = loc.tokens[this.startTokenIndex]; + if (util.comparePos(loc.start, token.loc.start) < 0) { + --this.startTokenIndex; + } + else + break; + } + // In the unlikely event that loc.tokens[this.endTokenIndex - 1] ends + // *before* loc.end, we need to fast-forward this.endTokenIndex first. + while (this.endTokenIndex < loc.tokens.length) { + var token = loc.tokens[this.endTokenIndex]; + if (util.comparePos(token.loc.end, loc.end) < 0) { + ++this.endTokenIndex; + } + else + break; + } + // Increment this.startTokenIndex until we've found the first token + // contained by this node. + while (this.startTokenIndex < this.endTokenIndex) { + var token = loc.tokens[this.startTokenIndex]; + if (util.comparePos(token.loc.start, loc.start) < 0) { + ++this.startTokenIndex; + } + else + break; + } + // Index into loc.tokens of the first token within this node. + loc.start.token = this.startTokenIndex; + // Decrement this.endTokenIndex until we've found the first token after + // this node (not contained by the node). + while (this.endTokenIndex > this.startTokenIndex) { + var token = loc.tokens[this.endTokenIndex - 1]; + if (util.comparePos(loc.end, token.loc.end) < 0) { + --this.endTokenIndex; + } + else + break; + } + // Index into loc.tokens of the first token *after* this node. + // If loc.start.token === loc.end.token, the node contains no tokens, + // and the index is that of the next token following this node. + loc.end.token = this.endTokenIndex; +}; diff --git a/tools/ui/node_modules/recast/lib/patcher.d.ts b/tools/ui/node_modules/recast/lib/patcher.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..dcc065c063c3c06d2dde565bdd4ddca79b3be552 --- /dev/null +++ b/tools/ui/node_modules/recast/lib/patcher.d.ts @@ -0,0 +1,12 @@ +interface PatcherType { + replace(loc: any, lines: any): any; + get(loc?: any): any; + tryToReprintComments(newNode: any, oldNode: any, print: any): any; + deleteComments(node: any): any; +} +interface PatcherConstructor { + new (lines: any): PatcherType; +} +declare const Patcher: PatcherConstructor; +export { Patcher }; +export declare function getReprinter(path: any): ((print: any) => any) | undefined; diff --git a/tools/ui/node_modules/recast/lib/patcher.js b/tools/ui/node_modules/recast/lib/patcher.js new file mode 100644 index 0000000000000000000000000000000000000000..f63f5cb4187d47b1f295e45c9b4358b5f402bd45 --- /dev/null +++ b/tools/ui/node_modules/recast/lib/patcher.js @@ -0,0 +1,386 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getReprinter = exports.Patcher = void 0; +var tslib_1 = require("tslib"); +var tiny_invariant_1 = tslib_1.__importDefault(require("tiny-invariant")); +var linesModule = tslib_1.__importStar(require("./lines")); +var types = tslib_1.__importStar(require("ast-types")); +var Printable = types.namedTypes.Printable; +var Expression = types.namedTypes.Expression; +var ReturnStatement = types.namedTypes.ReturnStatement; +var SourceLocation = types.namedTypes.SourceLocation; +var util_1 = require("./util"); +var fast_path_1 = tslib_1.__importDefault(require("./fast-path")); +var isObject = types.builtInTypes.object; +var isArray = types.builtInTypes.array; +var isString = types.builtInTypes.string; +var riskyAdjoiningCharExp = /[0-9a-z_$]/i; +var Patcher = function Patcher(lines) { + (0, tiny_invariant_1.default)(this instanceof Patcher); + (0, tiny_invariant_1.default)(lines instanceof linesModule.Lines); + var self = this, replacements = []; + self.replace = function (loc, lines) { + if (isString.check(lines)) + lines = linesModule.fromString(lines); + replacements.push({ + lines: lines, + start: loc.start, + end: loc.end, + }); + }; + self.get = function (loc) { + // If no location is provided, return the complete Lines object. + loc = loc || { + start: { line: 1, column: 0 }, + end: { line: lines.length, column: lines.getLineLength(lines.length) }, + }; + var sliceFrom = loc.start, toConcat = []; + function pushSlice(from, to) { + (0, tiny_invariant_1.default)((0, util_1.comparePos)(from, to) <= 0); + toConcat.push(lines.slice(from, to)); + } + replacements + .sort(function (a, b) { return (0, util_1.comparePos)(a.start, b.start); }) + .forEach(function (rep) { + if ((0, util_1.comparePos)(sliceFrom, rep.start) > 0) { + // Ignore nested replacement ranges. + } + else { + pushSlice(sliceFrom, rep.start); + toConcat.push(rep.lines); + sliceFrom = rep.end; + } + }); + pushSlice(sliceFrom, loc.end); + return linesModule.concat(toConcat); + }; +}; +exports.Patcher = Patcher; +var Pp = Patcher.prototype; +Pp.tryToReprintComments = function (newNode, oldNode, print) { + var patcher = this; + if (!newNode.comments && !oldNode.comments) { + // We were (vacuously) able to reprint all the comments! + return true; + } + var newPath = fast_path_1.default.from(newNode); + var oldPath = fast_path_1.default.from(oldNode); + newPath.stack.push("comments", getSurroundingComments(newNode)); + oldPath.stack.push("comments", getSurroundingComments(oldNode)); + var reprints = []; + var ableToReprintComments = findArrayReprints(newPath, oldPath, reprints); + // No need to pop anything from newPath.stack or oldPath.stack, since + // newPath and oldPath are fresh local variables. + if (ableToReprintComments && reprints.length > 0) { + reprints.forEach(function (reprint) { + var oldComment = reprint.oldPath.getValue(); + (0, tiny_invariant_1.default)(oldComment.leading || oldComment.trailing); + patcher.replace(oldComment.loc, + // Comments can't have .comments, so it doesn't matter whether we + // print with comments or without. + print(reprint.newPath).indentTail(oldComment.loc.indent)); + }); + } + return ableToReprintComments; +}; +// Get all comments that are either leading or trailing, ignoring any +// comments that occur inside node.loc. Returns an empty array for nodes +// with no leading or trailing comments. +function getSurroundingComments(node) { + var result = []; + if (node.comments && node.comments.length > 0) { + node.comments.forEach(function (comment) { + if (comment.leading || comment.trailing) { + result.push(comment); + } + }); + } + return result; +} +Pp.deleteComments = function (node) { + if (!node.comments) { + return; + } + var patcher = this; + node.comments.forEach(function (comment) { + if (comment.leading) { + // Delete leading comments along with any trailing whitespace they + // might have. + patcher.replace({ + start: comment.loc.start, + end: node.loc.lines.skipSpaces(comment.loc.end, false, false), + }, ""); + } + else if (comment.trailing) { + // Delete trailing comments along with any leading whitespace they + // might have. + patcher.replace({ + start: node.loc.lines.skipSpaces(comment.loc.start, true, false), + end: comment.loc.end, + }, ""); + } + }); +}; +function getReprinter(path) { + (0, tiny_invariant_1.default)(path instanceof fast_path_1.default); + // Make sure that this path refers specifically to a Node, rather than + // some non-Node subproperty of a Node. + var node = path.getValue(); + if (!Printable.check(node)) + return; + var orig = node.original; + var origLoc = orig && orig.loc; + var lines = origLoc && origLoc.lines; + var reprints = []; + if (!lines || !findReprints(path, reprints)) + return; + return function (print) { + var patcher = new Patcher(lines); + reprints.forEach(function (reprint) { + var newNode = reprint.newPath.getValue(); + var oldNode = reprint.oldPath.getValue(); + SourceLocation.assert(oldNode.loc, true); + var needToPrintNewPathWithComments = !patcher.tryToReprintComments(newNode, oldNode, print); + if (needToPrintNewPathWithComments) { + // Since we were not able to preserve all leading/trailing + // comments, we delete oldNode's comments, print newPath with + // comments, and then patch the resulting lines where oldNode used + // to be. + patcher.deleteComments(oldNode); + } + var newLines = print(reprint.newPath, { + includeComments: needToPrintNewPathWithComments, + // If the oldNode we're replacing already had parentheses, we may + // not need to print the new node with any extra parentheses, + // because the existing parentheses will suffice. However, if the + // newNode has a different type than the oldNode, let the printer + // decide if reprint.newPath needs parentheses, as usual. + avoidRootParens: oldNode.type === newNode.type && reprint.oldPath.hasParens(), + }).indentTail(oldNode.loc.indent); + var nls = needsLeadingSpace(lines, oldNode.loc, newLines); + var nts = needsTrailingSpace(lines, oldNode.loc, newLines); + // If we try to replace the argument of a ReturnStatement like + // return"asdf" with e.g. a literal null expression, we run the risk + // of ending up with returnnull, so we need to add an extra leading + // space in situations where that might happen. Likewise for + // "asdf"in obj. See #170. + if (nls || nts) { + var newParts = []; + nls && newParts.push(" "); + newParts.push(newLines); + nts && newParts.push(" "); + newLines = linesModule.concat(newParts); + } + patcher.replace(oldNode.loc, newLines); + }); + // Recall that origLoc is the .loc of an ancestor node that is + // guaranteed to contain all the reprinted nodes and comments. + var patchedLines = patcher.get(origLoc).indentTail(-orig.loc.indent); + if (path.needsParens()) { + return linesModule.concat(["(", patchedLines, ")"]); + } + return patchedLines; + }; +} +exports.getReprinter = getReprinter; +// If the last character before oldLoc and the first character of newLines +// are both identifier characters, they must be separated by a space, +// otherwise they will most likely get fused together into a single token. +function needsLeadingSpace(oldLines, oldLoc, newLines) { + var posBeforeOldLoc = (0, util_1.copyPos)(oldLoc.start); + // The character just before the location occupied by oldNode. + var charBeforeOldLoc = oldLines.prevPos(posBeforeOldLoc) && oldLines.charAt(posBeforeOldLoc); + // First character of the reprinted node. + var newFirstChar = newLines.charAt(newLines.firstPos()); + return (charBeforeOldLoc && + riskyAdjoiningCharExp.test(charBeforeOldLoc) && + newFirstChar && + riskyAdjoiningCharExp.test(newFirstChar)); +} +// If the last character of newLines and the first character after oldLoc +// are both identifier characters, they must be separated by a space, +// otherwise they will most likely get fused together into a single token. +function needsTrailingSpace(oldLines, oldLoc, newLines) { + // The character just after the location occupied by oldNode. + var charAfterOldLoc = oldLines.charAt(oldLoc.end); + var newLastPos = newLines.lastPos(); + // Last character of the reprinted node. + var newLastChar = newLines.prevPos(newLastPos) && newLines.charAt(newLastPos); + return (newLastChar && + riskyAdjoiningCharExp.test(newLastChar) && + charAfterOldLoc && + riskyAdjoiningCharExp.test(charAfterOldLoc)); +} +function findReprints(newPath, reprints) { + var newNode = newPath.getValue(); + Printable.assert(newNode); + var oldNode = newNode.original; + Printable.assert(oldNode); + (0, tiny_invariant_1.default)(reprints.length === 0); + if (newNode.type !== oldNode.type) { + return false; + } + var oldPath = new fast_path_1.default(oldNode); + var canReprint = findChildReprints(newPath, oldPath, reprints); + if (!canReprint) { + // Make absolutely sure the calling code does not attempt to reprint + // any nodes. + reprints.length = 0; + } + return canReprint; +} +function findAnyReprints(newPath, oldPath, reprints) { + var newNode = newPath.getValue(); + var oldNode = oldPath.getValue(); + if (newNode === oldNode) + return true; + if (isArray.check(newNode)) + return findArrayReprints(newPath, oldPath, reprints); + if (isObject.check(newNode)) + return findObjectReprints(newPath, oldPath, reprints); + return false; +} +function findArrayReprints(newPath, oldPath, reprints) { + var newNode = newPath.getValue(); + var oldNode = oldPath.getValue(); + if (newNode === oldNode || + newPath.valueIsDuplicate() || + oldPath.valueIsDuplicate()) { + return true; + } + isArray.assert(newNode); + var len = newNode.length; + if (!(isArray.check(oldNode) && oldNode.length === len)) + return false; + for (var i = 0; i < len; ++i) { + newPath.stack.push(i, newNode[i]); + oldPath.stack.push(i, oldNode[i]); + var canReprint = findAnyReprints(newPath, oldPath, reprints); + newPath.stack.length -= 2; + oldPath.stack.length -= 2; + if (!canReprint) { + return false; + } + } + return true; +} +function findObjectReprints(newPath, oldPath, reprints) { + var newNode = newPath.getValue(); + isObject.assert(newNode); + if (newNode.original === null) { + // If newNode.original node was set to null, reprint the node. + return false; + } + var oldNode = oldPath.getValue(); + if (!isObject.check(oldNode)) + return false; + if (newNode === oldNode || + newPath.valueIsDuplicate() || + oldPath.valueIsDuplicate()) { + return true; + } + if (Printable.check(newNode)) { + if (!Printable.check(oldNode)) { + return false; + } + var newParentNode = newPath.getParentNode(); + var oldParentNode = oldPath.getParentNode(); + if (oldParentNode !== null && + oldParentNode.type === "FunctionTypeAnnotation" && + newParentNode !== null && + newParentNode.type === "FunctionTypeAnnotation") { + var oldNeedsParens = oldParentNode.params.length !== 1 || !!oldParentNode.params[0].name; + var newNeedParens = newParentNode.params.length !== 1 || !!newParentNode.params[0].name; + if (!oldNeedsParens && newNeedParens) { + return false; + } + } + // Here we need to decide whether the reprinted code for newNode is + // appropriate for patching into the location of oldNode. + if (newNode.type === oldNode.type) { + var childReprints = []; + if (findChildReprints(newPath, oldPath, childReprints)) { + reprints.push.apply(reprints, childReprints); + } + else if (oldNode.loc) { + // If we have no .loc information for oldNode, then we won't be + // able to reprint it. + reprints.push({ + oldPath: oldPath.copy(), + newPath: newPath.copy(), + }); + } + else { + return false; + } + return true; + } + if (Expression.check(newNode) && + Expression.check(oldNode) && + // If we have no .loc information for oldNode, then we won't be + // able to reprint it. + oldNode.loc) { + // If both nodes are subtypes of Expression, then we should be able + // to fill the location occupied by the old node with code printed + // for the new node with no ill consequences. + reprints.push({ + oldPath: oldPath.copy(), + newPath: newPath.copy(), + }); + return true; + } + // The nodes have different types, and at least one of the types is + // not a subtype of the Expression type, so we cannot safely assume + // the nodes are syntactically interchangeable. + return false; + } + return findChildReprints(newPath, oldPath, reprints); +} +function findChildReprints(newPath, oldPath, reprints) { + var newNode = newPath.getValue(); + var oldNode = oldPath.getValue(); + isObject.assert(newNode); + isObject.assert(oldNode); + if (newNode.original === null) { + // If newNode.original node was set to null, reprint the node. + return false; + } + // If this node needs parentheses and will not be wrapped with + // parentheses when reprinted, then return false to skip reprinting and + // let it be printed generically. + if (newPath.needsParens() && !oldPath.hasParens()) { + return false; + } + var keys = (0, util_1.getUnionOfKeys)(oldNode, newNode); + if (oldNode.type === "File" || newNode.type === "File") { + // Don't bother traversing file.tokens, an often very large array + // returned by Babylon, and useless for our purposes. + delete keys.tokens; + } + // Don't bother traversing .loc objects looking for reprintable nodes. + delete keys.loc; + var originalReprintCount = reprints.length; + for (var k in keys) { + if (k.charAt(0) === "_") { + // Ignore "private" AST properties added by e.g. Babel plugins and + // parsers like Babylon. + continue; + } + newPath.stack.push(k, types.getFieldValue(newNode, k)); + oldPath.stack.push(k, types.getFieldValue(oldNode, k)); + var canReprint = findAnyReprints(newPath, oldPath, reprints); + newPath.stack.length -= 2; + oldPath.stack.length -= 2; + if (!canReprint) { + return false; + } + } + // Return statements might end up running into ASI issues due to + // comments inserted deep within the tree, so reprint them if anything + // changed within them. + if (ReturnStatement.check(newPath.getNode()) && + reprints.length > originalReprintCount) { + return false; + } + return true; +} diff --git a/tools/ui/node_modules/recast/lib/printer.d.ts b/tools/ui/node_modules/recast/lib/printer.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d8e2cfa1dd8a25ad4482d992eab3a6e8b32dc99d --- /dev/null +++ b/tools/ui/node_modules/recast/lib/printer.d.ts @@ -0,0 +1,14 @@ +export interface PrintResultType { + code: string; + map?: any; + toString(): string; +} +interface PrinterType { + print(ast: any): PrintResultType; + printGenerically(ast: any): PrintResultType; +} +interface PrinterConstructor { + new (config?: any): PrinterType; +} +declare const Printer: PrinterConstructor; +export { Printer }; diff --git a/tools/ui/node_modules/recast/lib/printer.js b/tools/ui/node_modules/recast/lib/printer.js new file mode 100644 index 0000000000000000000000000000000000000000..8697765353f191e8e2a9a6b35242c2416232d34a --- /dev/null +++ b/tools/ui/node_modules/recast/lib/printer.js @@ -0,0 +1,2406 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Printer = void 0; +var tslib_1 = require("tslib"); +var tiny_invariant_1 = tslib_1.__importDefault(require("tiny-invariant")); +var types = tslib_1.__importStar(require("ast-types")); +var comments_1 = require("./comments"); +var fast_path_1 = tslib_1.__importDefault(require("./fast-path")); +var lines_1 = require("./lines"); +var options_1 = require("./options"); +var patcher_1 = require("./patcher"); +var util = tslib_1.__importStar(require("./util")); +var namedTypes = types.namedTypes; +var isString = types.builtInTypes.string; +var isObject = types.builtInTypes.object; +var PrintResult = function PrintResult(code, sourceMap) { + (0, tiny_invariant_1.default)(this instanceof PrintResult); + isString.assert(code); + this.code = code; + if (sourceMap) { + isObject.assert(sourceMap); + this.map = sourceMap; + } +}; +var PRp = PrintResult.prototype; +var warnedAboutToString = false; +PRp.toString = function () { + if (!warnedAboutToString) { + console.warn("Deprecation warning: recast.print now returns an object with " + + "a .code property. You appear to be treating the object as a " + + "string, which might still work but is strongly discouraged."); + warnedAboutToString = true; + } + return this.code; +}; +var emptyPrintResult = new PrintResult(""); +var Printer = function Printer(config) { + (0, tiny_invariant_1.default)(this instanceof Printer); + var explicitTabWidth = config && config.tabWidth; + config = (0, options_1.normalize)(config); + // It's common for client code to pass the same options into both + // recast.parse and recast.print, but the Printer doesn't need (and + // can be confused by) config.sourceFileName, so we null it out. + config.sourceFileName = null; + // Non-destructively modifies options with overrides, and returns a + // new print function that uses the modified options. + function makePrintFunctionWith(options, overrides) { + options = Object.assign({}, options, overrides); + return function (path) { return print(path, options); }; + } + function print(path, options) { + (0, tiny_invariant_1.default)(path instanceof fast_path_1.default); + options = options || {}; + if (options.includeComments) { + return (0, comments_1.printComments)(path, makePrintFunctionWith(options, { + includeComments: false, + })); + } + var oldTabWidth = config.tabWidth; + if (!explicitTabWidth) { + var loc = path.getNode().loc; + if (loc && loc.lines && loc.lines.guessTabWidth) { + config.tabWidth = loc.lines.guessTabWidth(); + } + } + var reprinter = (0, patcher_1.getReprinter)(path); + var lines = reprinter + ? // Since the print function that we pass to the reprinter will + // be used to print "new" nodes, it's tempting to think we + // should pass printRootGenerically instead of print, to avoid + // calling maybeReprint again, but that would be a mistake + // because the new nodes might not be entirely new, but merely + // moved from elsewhere in the AST. The print function is the + // right choice because it gives us the opportunity to reprint + // such nodes using their original source. + reprinter(print) + : genericPrint(path, config, options, makePrintFunctionWith(options, { + includeComments: true, + avoidRootParens: false, + })); + config.tabWidth = oldTabWidth; + return lines; + } + this.print = function (ast) { + if (!ast) { + return emptyPrintResult; + } + var lines = print(fast_path_1.default.from(ast), { + includeComments: true, + avoidRootParens: false, + }); + return new PrintResult(lines.toString(config), util.composeSourceMaps(config.inputSourceMap, lines.getSourceMap(config.sourceMapName, config.sourceRoot))); + }; + this.printGenerically = function (ast) { + if (!ast) { + return emptyPrintResult; + } + // Print the entire AST generically. + function printGenerically(path) { + return (0, comments_1.printComments)(path, function (path) { + return genericPrint(path, config, { + includeComments: true, + avoidRootParens: false, + }, printGenerically); + }); + } + var path = fast_path_1.default.from(ast); + var oldReuseWhitespace = config.reuseWhitespace; + // Do not reuse whitespace (or anything else, for that matter) + // when printing generically. + config.reuseWhitespace = false; + // TODO Allow printing of comments? + var pr = new PrintResult(printGenerically(path).toString(config)); + config.reuseWhitespace = oldReuseWhitespace; + return pr; + }; +}; +exports.Printer = Printer; +function genericPrint(path, config, options, printPath) { + (0, tiny_invariant_1.default)(path instanceof fast_path_1.default); + var node = path.getValue(); + var parts = []; + var linesWithoutParens = genericPrintNoParens(path, config, printPath); + if (!node || linesWithoutParens.isEmpty()) { + return linesWithoutParens; + } + var shouldAddParens = false; + var decoratorsLines = printDecorators(path, printPath); + if (decoratorsLines.isEmpty()) { + // Nodes with decorators can't have parentheses, so we can avoid + // computing path.needsParens() except in this case. + if (!options.avoidRootParens) { + shouldAddParens = path.needsParens(); + } + } + else { + parts.push(decoratorsLines); + } + if (shouldAddParens) { + parts.unshift("("); + } + parts.push(linesWithoutParens); + if (shouldAddParens) { + parts.push(")"); + } + return (0, lines_1.concat)(parts); +} +// Note that the `options` parameter of this function is what other +// functions in this file call the `config` object (that is, the +// configuration object originally passed into the Printer constructor). +// Its properties are documented in lib/options.js. +function genericPrintNoParens(path, options, print) { + var _a, _b, _c; + var n = path.getValue(); + if (!n) { + return (0, lines_1.fromString)(""); + } + if (typeof n === "string") { + return (0, lines_1.fromString)(n, options); + } + namedTypes.Printable.assert(n); + var parts = []; + switch (n.type) { + case "File": + return path.call(print, "program"); + case "Program": + // Babel 6 + if (n.directives) { + path.each(function (childPath) { + parts.push(print(childPath), ";\n"); + }, "directives"); + } + if (n.interpreter) { + parts.push(path.call(print, "interpreter")); + } + parts.push(path.call(function (bodyPath) { return printStatementSequence(bodyPath, options, print); }, "body")); + return (0, lines_1.concat)(parts); + case "Noop": // Babel extension. + case "EmptyStatement": + return (0, lines_1.fromString)(""); + case "ExpressionStatement": + return (0, lines_1.concat)([path.call(print, "expression"), ";"]); + case "ParenthesizedExpression": // Babel extension. + return (0, lines_1.concat)(["(", path.call(print, "expression"), ")"]); + case "BinaryExpression": + case "LogicalExpression": + case "AssignmentExpression": + return (0, lines_1.fromString)(" ").join([ + path.call(print, "left"), + n.operator, + path.call(print, "right"), + ]); + case "AssignmentPattern": + return (0, lines_1.concat)([ + path.call(print, "left"), + " = ", + path.call(print, "right"), + ]); + case "MemberExpression": + case "OptionalMemberExpression": { + parts.push(path.call(print, "object")); + var property = path.call(print, "property"); + // Like n.optional, except with defaults applied, so optional + // defaults to true for OptionalMemberExpression nodes. + var optional = types.getFieldValue(n, "optional"); + if (n.computed) { + parts.push(optional ? "?.[" : "[", property, "]"); + } + else { + parts.push(optional ? "?." : ".", property); + } + return (0, lines_1.concat)(parts); + } + case "ChainExpression": + return path.call(print, "expression"); + case "MetaProperty": + return (0, lines_1.concat)([ + path.call(print, "meta"), + ".", + path.call(print, "property"), + ]); + case "BindExpression": + if (n.object) { + parts.push(path.call(print, "object")); + } + parts.push("::", path.call(print, "callee")); + return (0, lines_1.concat)(parts); + case "Path": + return (0, lines_1.fromString)(".").join(n.body); + case "Identifier": + return (0, lines_1.concat)([ + (0, lines_1.fromString)(n.name, options), + n.optional ? "?" : "", + path.call(print, "typeAnnotation"), + ]); + case "SpreadElement": + case "SpreadElementPattern": + case "RestProperty": // Babel 6 for ObjectPattern + case "SpreadProperty": + case "SpreadPropertyPattern": + case "ObjectTypeSpreadProperty": + case "RestElement": + return (0, lines_1.concat)([ + "...", + path.call(print, "argument"), + path.call(print, "typeAnnotation"), + ]); + case "FunctionDeclaration": + case "FunctionExpression": + case "TSDeclareFunction": + if (n.declare) { + parts.push("declare "); + } + if (n.async) { + parts.push("async "); + } + parts.push("function"); + if (n.generator) + parts.push("*"); + if (n.id) { + parts.push(" ", path.call(print, "id"), path.call(print, "typeParameters")); + } + else { + if (n.typeParameters) { + parts.push(path.call(print, "typeParameters")); + } + } + parts.push("(", printFunctionParams(path, options, print), ")", path.call(print, "returnType")); + if (n.body) { + parts.push(" ", path.call(print, "body")); + } + return (0, lines_1.concat)(parts); + case "ArrowFunctionExpression": + if (n.async) { + parts.push("async "); + } + if (n.typeParameters) { + parts.push(path.call(print, "typeParameters")); + } + if (!options.arrowParensAlways && + n.params.length === 1 && + !n.rest && + n.params[0].type === "Identifier" && + !n.params[0].typeAnnotation && + !n.returnType) { + parts.push(path.call(print, "params", 0)); + } + else { + parts.push("(", printFunctionParams(path, options, print), ")", path.call(print, "returnType")); + } + parts.push(" => ", path.call(print, "body")); + return (0, lines_1.concat)(parts); + case "MethodDefinition": + return printMethod(path, options, print); + case "YieldExpression": + parts.push("yield"); + if (n.delegate) + parts.push("*"); + if (n.argument) + parts.push(" ", path.call(print, "argument")); + return (0, lines_1.concat)(parts); + case "AwaitExpression": + parts.push("await"); + if (n.all) + parts.push("*"); + if (n.argument) + parts.push(" ", path.call(print, "argument")); + return (0, lines_1.concat)(parts); + case "ModuleExpression": + return (0, lines_1.concat)([ + "module {\n", + path.call(print, "body").indent(options.tabWidth), + "\n}", + ]); + case "ModuleDeclaration": + parts.push("module", path.call(print, "id")); + if (n.source) { + (0, tiny_invariant_1.default)(!n.body); + parts.push("from", path.call(print, "source")); + } + else { + parts.push(path.call(print, "body")); + } + return (0, lines_1.fromString)(" ").join(parts); + case "ImportSpecifier": + if (n.importKind && n.importKind !== "value") { + parts.push(n.importKind + " "); + } + if (n.imported) { + parts.push(path.call(print, "imported")); + if (n.local && n.local.name !== n.imported.name) { + parts.push(" as ", path.call(print, "local")); + } + } + else if (n.id) { + parts.push(path.call(print, "id")); + if (n.name) { + parts.push(" as ", path.call(print, "name")); + } + } + return (0, lines_1.concat)(parts); + case "ExportSpecifier": + if (n.exportKind && n.exportKind !== "value") { + parts.push(n.exportKind + " "); + } + if (n.local) { + parts.push(path.call(print, "local")); + if (n.exported && n.exported.name !== n.local.name) { + parts.push(" as ", path.call(print, "exported")); + } + } + else if (n.id) { + parts.push(path.call(print, "id")); + if (n.name) { + parts.push(" as ", path.call(print, "name")); + } + } + return (0, lines_1.concat)(parts); + case "ExportBatchSpecifier": + return (0, lines_1.fromString)("*"); + case "ImportNamespaceSpecifier": + parts.push("* as "); + if (n.local) { + parts.push(path.call(print, "local")); + } + else if (n.id) { + parts.push(path.call(print, "id")); + } + return (0, lines_1.concat)(parts); + case "ImportDefaultSpecifier": + if (n.local) { + return path.call(print, "local"); + } + return path.call(print, "id"); + case "TSExportAssignment": + return (0, lines_1.concat)(["export = ", path.call(print, "expression")]); + case "ExportDeclaration": + case "ExportDefaultDeclaration": + case "ExportNamedDeclaration": + return printExportDeclaration(path, options, print); + case "ExportAllDeclaration": + parts.push("export *"); + if (n.exported) { + parts.push(" as ", path.call(print, "exported")); + } + parts.push(" from ", path.call(print, "source"), ";"); + return (0, lines_1.concat)(parts); + case "TSNamespaceExportDeclaration": + parts.push("export as namespace ", path.call(print, "id")); + return maybeAddSemicolon((0, lines_1.concat)(parts)); + case "ExportNamespaceSpecifier": + return (0, lines_1.concat)(["* as ", path.call(print, "exported")]); + case "ExportDefaultSpecifier": + return path.call(print, "exported"); + case "Import": + return (0, lines_1.fromString)("import", options); + // Recast and ast-types currently support dynamic import(...) using + // either this dedicated ImportExpression type or a CallExpression + // whose callee has type Import. + // https://github.com/benjamn/ast-types/pull/365#issuecomment-605214486 + case "ImportExpression": + return (0, lines_1.concat)(["import(", path.call(print, "source"), ")"]); + case "ImportDeclaration": { + parts.push("import "); + if (n.importKind && n.importKind !== "value") { + parts.push(n.importKind + " "); + } + if (n.specifiers && n.specifiers.length > 0) { + var unbracedSpecifiers_1 = []; + var bracedSpecifiers_1 = []; + path.each(function (specifierPath) { + var spec = specifierPath.getValue(); + if (spec.type === "ImportSpecifier") { + bracedSpecifiers_1.push(print(specifierPath)); + } + else if (spec.type === "ImportDefaultSpecifier" || + spec.type === "ImportNamespaceSpecifier") { + unbracedSpecifiers_1.push(print(specifierPath)); + } + }, "specifiers"); + unbracedSpecifiers_1.forEach(function (lines, i) { + if (i > 0) { + parts.push(", "); + } + parts.push(lines); + }); + if (bracedSpecifiers_1.length > 0) { + var lines = (0, lines_1.fromString)(", ").join(bracedSpecifiers_1); + if (lines.getLineLength(1) > options.wrapColumn) { + lines = (0, lines_1.concat)([ + (0, lines_1.fromString)(",\n").join(bracedSpecifiers_1).indent(options.tabWidth), + ",", + ]); + } + if (unbracedSpecifiers_1.length > 0) { + parts.push(", "); + } + if (lines.length > 1) { + parts.push("{\n", lines, "\n}"); + } + else if (options.objectCurlySpacing) { + parts.push("{ ", lines, " }"); + } + else { + parts.push("{", lines, "}"); + } + } + parts.push(" from "); + } + parts.push(path.call(print, "source"), maybePrintImportAssertions(path, options, print), ";"); + return (0, lines_1.concat)(parts); + } + case "ImportAttribute": + return (0, lines_1.concat)([path.call(print, "key"), ": ", path.call(print, "value")]); + case "StaticBlock": + parts.push("static "); + // Intentionally fall through to BlockStatement below. + case "BlockStatement": { + var naked_1 = path.call(function (bodyPath) { return printStatementSequence(bodyPath, options, print); }, "body"); + if (naked_1.isEmpty()) { + if (!n.directives || n.directives.length === 0) { + parts.push("{}"); + return (0, lines_1.concat)(parts); + } + } + parts.push("{\n"); + // Babel 6 + if (n.directives) { + path.each(function (childPath) { + parts.push(maybeAddSemicolon(print(childPath).indent(options.tabWidth)), n.directives.length > 1 || !naked_1.isEmpty() ? "\n" : ""); + }, "directives"); + } + parts.push(naked_1.indent(options.tabWidth)); + parts.push("\n}"); + return (0, lines_1.concat)(parts); + } + case "ReturnStatement": { + parts.push("return"); + if (n.argument) { + var argIsJsxElement = ((_a = namedTypes.JSXElement) === null || _a === void 0 ? void 0 : _a.check(n.argument)) || + ((_b = namedTypes.JSXFragment) === null || _b === void 0 ? void 0 : _b.check(n.argument)); + var argLines = path.call(print, "argument"); + if (argLines.startsWithComment() || + (argLines.length > 1 && argIsJsxElement)) { + // Babel: regenerate parenthesized jsxElements so we don't double parentheses + if (argIsJsxElement && ((_c = n.argument.extra) === null || _c === void 0 ? void 0 : _c.parenthesized)) { + n.argument.extra.parenthesized = false; + argLines = path.call(print, "argument"); + n.argument.extra.parenthesized = true; + } + parts.push(" ", (0, lines_1.concat)(["(\n", argLines]).indentTail(options.tabWidth), "\n)"); + } + else { + parts.push(" ", argLines); + } + } + parts.push(";"); + return (0, lines_1.concat)(parts); + } + case "CallExpression": + case "OptionalCallExpression": + parts.push(path.call(print, "callee")); + if (n.typeParameters) { + parts.push(path.call(print, "typeParameters")); + } + if (n.typeArguments) { + parts.push(path.call(print, "typeArguments")); + } + // Like n.optional, but defaults to true for OptionalCallExpression + // nodes that are missing an n.optional property (unusual), + // according to the OptionalCallExpression definition in ast-types. + if (types.getFieldValue(n, "optional")) { + parts.push("?."); + } + parts.push(printArgumentsList(path, options, print)); + return (0, lines_1.concat)(parts); + case "RecordExpression": + parts.push("#"); + // Intentionally fall through to printing the object literal... + case "ObjectExpression": + case "ObjectPattern": + case "ObjectTypeAnnotation": { + var isTypeAnnotation_1 = n.type === "ObjectTypeAnnotation"; + var separator_1 = options.flowObjectCommas + ? "," + : isTypeAnnotation_1 + ? ";" + : ","; + var fields = []; + var allowBreak_1 = false; + if (isTypeAnnotation_1) { + fields.push("indexers", "callProperties"); + if (n.internalSlots != null) { + fields.push("internalSlots"); + } + } + fields.push("properties"); + var len_1 = 0; + fields.forEach(function (field) { + len_1 += n[field].length; + }); + var oneLine_1 = (isTypeAnnotation_1 && len_1 === 1) || len_1 === 0; + var leftBrace = n.exact ? "{|" : "{"; + var rightBrace = n.exact ? "|}" : "}"; + parts.push(oneLine_1 ? leftBrace : leftBrace + "\n"); + var leftBraceIndex = parts.length - 1; + var i_1 = 0; + fields.forEach(function (field) { + path.each(function (childPath) { + var lines = print(childPath); + if (!oneLine_1) { + lines = lines.indent(options.tabWidth); + } + var multiLine = !isTypeAnnotation_1 && lines.length > 1; + if (multiLine && allowBreak_1) { + // Similar to the logic for BlockStatement. + parts.push("\n"); + } + parts.push(lines); + if (i_1 < len_1 - 1) { + // Add an extra line break if the previous object property + // had a multi-line value. + parts.push(separator_1 + (multiLine ? "\n\n" : "\n")); + allowBreak_1 = !multiLine; + } + else if (len_1 !== 1 && isTypeAnnotation_1) { + parts.push(separator_1); + } + else if (!oneLine_1 && + util.isTrailingCommaEnabled(options, "objects") && + childPath.getValue().type !== "RestElement") { + parts.push(separator_1); + } + i_1++; + }, field); + }); + if (n.inexact) { + var line = (0, lines_1.fromString)("...", options); + if (oneLine_1) { + if (len_1 > 0) { + parts.push(separator_1, " "); + } + parts.push(line); + } + else { + // No trailing separator after ... to maintain parity with prettier. + parts.push("\n", line.indent(options.tabWidth)); + } + } + parts.push(oneLine_1 ? rightBrace : "\n" + rightBrace); + if (i_1 !== 0 && oneLine_1 && options.objectCurlySpacing) { + parts[leftBraceIndex] = leftBrace + " "; + parts[parts.length - 1] = " " + rightBrace; + } + if (n.typeAnnotation) { + parts.push(path.call(print, "typeAnnotation")); + } + return (0, lines_1.concat)(parts); + } + case "PropertyPattern": + return (0, lines_1.concat)([ + path.call(print, "key"), + ": ", + path.call(print, "pattern"), + ]); + case "ObjectProperty": // Babel 6 + case "Property": { + // Non-standard AST node type. + if (n.method || n.kind === "get" || n.kind === "set") { + return printMethod(path, options, print); + } + if (n.shorthand && n.value.type === "AssignmentPattern") { + return path.call(print, "value"); + } + var key = path.call(print, "key"); + if (n.computed) { + parts.push("[", key, "]"); + } + else { + parts.push(key); + } + if (!n.shorthand || n.key.name !== n.value.name) { + parts.push(": ", path.call(print, "value")); + } + return (0, lines_1.concat)(parts); + } + case "ClassMethod": // Babel 6 + case "ObjectMethod": // Babel 6 + case "ClassPrivateMethod": + case "TSDeclareMethod": + return printMethod(path, options, print); + case "PrivateName": + return (0, lines_1.concat)(["#", path.call(print, "id")]); + case "Decorator": + return (0, lines_1.concat)(["@", path.call(print, "expression")]); + case "TupleExpression": + parts.push("#"); + // Intentionally fall through to printing the tuple elements... + case "ArrayExpression": + case "ArrayPattern": { + var elems = n.elements; + var len_2 = elems.length; + var printed_1 = path.map(print, "elements"); + var joined = (0, lines_1.fromString)(", ").join(printed_1); + var oneLine_2 = joined.getLineLength(1) <= options.wrapColumn; + if (oneLine_2) { + if (options.arrayBracketSpacing) { + parts.push("[ "); + } + else { + parts.push("["); + } + } + else { + parts.push("[\n"); + } + path.each(function (elemPath) { + var i = elemPath.getName(); + var elem = elemPath.getValue(); + if (!elem) { + // If the array expression ends with a hole, that hole + // will be ignored by the interpreter, but if it ends with + // two (or more) holes, we need to write out two (or more) + // commas so that the resulting code is interpreted with + // both (all) of the holes. + parts.push(","); + } + else { + var lines = printed_1[i]; + if (oneLine_2) { + if (i > 0) + parts.push(" "); + } + else { + lines = lines.indent(options.tabWidth); + } + parts.push(lines); + if (i < len_2 - 1 || + (!oneLine_2 && util.isTrailingCommaEnabled(options, "arrays"))) + parts.push(","); + if (!oneLine_2) + parts.push("\n"); + } + }, "elements"); + if (oneLine_2 && options.arrayBracketSpacing) { + parts.push(" ]"); + } + else { + parts.push("]"); + } + if (n.typeAnnotation) { + parts.push(path.call(print, "typeAnnotation")); + } + return (0, lines_1.concat)(parts); + } + case "SequenceExpression": + return (0, lines_1.fromString)(", ").join(path.map(print, "expressions")); + case "ThisExpression": + return (0, lines_1.fromString)("this"); + case "Super": + return (0, lines_1.fromString)("super"); + case "NullLiteral": // Babel 6 Literal split + return (0, lines_1.fromString)("null"); + case "RegExpLiteral": // Babel 6 Literal split + return (0, lines_1.fromString)(getPossibleRaw(n) || "/".concat(n.pattern, "/").concat(n.flags || ""), options); + case "BigIntLiteral": // Babel 7 Literal split + return (0, lines_1.fromString)(getPossibleRaw(n) || n.value + "n", options); + case "NumericLiteral": // Babel 6 Literal Split + return (0, lines_1.fromString)(getPossibleRaw(n) || n.value, options); + case "DecimalLiteral": + return (0, lines_1.fromString)(getPossibleRaw(n) || n.value + "m", options); + case "StringLiteral": + return (0, lines_1.fromString)(nodeStr(n.value, options)); + case "BooleanLiteral": // Babel 6 Literal split + case "Literal": + return (0, lines_1.fromString)(getPossibleRaw(n) || + (typeof n.value === "string" ? nodeStr(n.value, options) : n.value), options); + case "Directive": // Babel 6 + return path.call(print, "value"); + case "DirectiveLiteral": // Babel 6 + return (0, lines_1.fromString)(getPossibleRaw(n) || nodeStr(n.value, options), options); + case "InterpreterDirective": + return (0, lines_1.fromString)("#!".concat(n.value, "\n"), options); + case "ModuleSpecifier": + if (n.local) { + throw new Error("The ESTree ModuleSpecifier type should be abstract"); + } + // The Esprima ModuleSpecifier type is just a string-valued + // Literal identifying the imported-from module. + return (0, lines_1.fromString)(nodeStr(n.value, options), options); + case "UnaryExpression": + parts.push(n.operator); + if (/[a-z]$/.test(n.operator)) + parts.push(" "); + parts.push(path.call(print, "argument")); + return (0, lines_1.concat)(parts); + case "UpdateExpression": + parts.push(path.call(print, "argument"), n.operator); + if (n.prefix) + parts.reverse(); + return (0, lines_1.concat)(parts); + case "ConditionalExpression": + return (0, lines_1.concat)([ + path.call(print, "test"), + " ? ", + path.call(print, "consequent"), + " : ", + path.call(print, "alternate"), + ]); + case "NewExpression": { + parts.push("new ", path.call(print, "callee")); + if (n.typeParameters) { + parts.push(path.call(print, "typeParameters")); + } + if (n.typeArguments) { + parts.push(path.call(print, "typeArguments")); + } + var args = n.arguments; + if (args) { + parts.push(printArgumentsList(path, options, print)); + } + return (0, lines_1.concat)(parts); + } + case "VariableDeclaration": { + if (n.declare) { + parts.push("declare "); + } + parts.push(n.kind, " "); + var maxLen_1 = 0; + var printed = path.map(function (childPath) { + var lines = print(childPath); + maxLen_1 = Math.max(lines.length, maxLen_1); + return lines; + }, "declarations"); + if (maxLen_1 === 1) { + parts.push((0, lines_1.fromString)(", ").join(printed)); + } + else if (printed.length > 1) { + parts.push((0, lines_1.fromString)(",\n") + .join(printed) + .indentTail(n.kind.length + 1)); + } + else { + parts.push(printed[0]); + } + // We generally want to terminate all variable declarations with a + // semicolon, except when they are children of for loops. + var parentNode = path.getParentNode(); + if (!namedTypes.ForStatement.check(parentNode) && + !namedTypes.ForInStatement.check(parentNode) && + !(namedTypes.ForOfStatement && + namedTypes.ForOfStatement.check(parentNode)) && + !(namedTypes.ForAwaitStatement && + namedTypes.ForAwaitStatement.check(parentNode))) { + parts.push(";"); + } + return (0, lines_1.concat)(parts); + } + case "VariableDeclarator": + return n.init + ? (0, lines_1.fromString)(" = ").join([ + path.call(print, "id"), + path.call(print, "init"), + ]) + : path.call(print, "id"); + case "WithStatement": + return (0, lines_1.concat)([ + "with (", + path.call(print, "object"), + ") ", + path.call(print, "body"), + ]); + case "IfStatement": { + var con = adjustClause(path.call(print, "consequent"), options); + parts.push("if (", path.call(print, "test"), ")", con); + if (n.alternate) + parts.push(endsWithBrace(con) ? " else" : "\nelse", adjustClause(path.call(print, "alternate"), options)); + return (0, lines_1.concat)(parts); + } + case "ForStatement": { + // TODO Get the for (;;) case right. + var init = path.call(print, "init"); + var sep = init.length > 1 ? ";\n" : "; "; + var forParen = "for ("; + var indented = (0, lines_1.fromString)(sep) + .join([init, path.call(print, "test"), path.call(print, "update")]) + .indentTail(forParen.length); + var head = (0, lines_1.concat)([forParen, indented, ")"]); + var clause = adjustClause(path.call(print, "body"), options); + parts.push(head); + if (head.length > 1) { + parts.push("\n"); + clause = clause.trimLeft(); + } + parts.push(clause); + return (0, lines_1.concat)(parts); + } + case "WhileStatement": + return (0, lines_1.concat)([ + "while (", + path.call(print, "test"), + ")", + adjustClause(path.call(print, "body"), options), + ]); + case "ForInStatement": + // Note: esprima can't actually parse "for each (". + return (0, lines_1.concat)([ + n.each ? "for each (" : "for (", + path.call(print, "left"), + " in ", + path.call(print, "right"), + ")", + adjustClause(path.call(print, "body"), options), + ]); + case "ForOfStatement": + case "ForAwaitStatement": + parts.push("for "); + if (n.await || n.type === "ForAwaitStatement") { + parts.push("await "); + } + parts.push("(", path.call(print, "left"), " of ", path.call(print, "right"), ")", adjustClause(path.call(print, "body"), options)); + return (0, lines_1.concat)(parts); + case "DoWhileStatement": { + var doBody = (0, lines_1.concat)([ + "do", + adjustClause(path.call(print, "body"), options), + ]); + parts.push(doBody); + if (endsWithBrace(doBody)) + parts.push(" while"); + else + parts.push("\nwhile"); + parts.push(" (", path.call(print, "test"), ");"); + return (0, lines_1.concat)(parts); + } + case "DoExpression": { + var statements = path.call(function (bodyPath) { return printStatementSequence(bodyPath, options, print); }, "body"); + return (0, lines_1.concat)(["do {\n", statements.indent(options.tabWidth), "\n}"]); + } + case "BreakStatement": + parts.push("break"); + if (n.label) + parts.push(" ", path.call(print, "label")); + parts.push(";"); + return (0, lines_1.concat)(parts); + case "ContinueStatement": + parts.push("continue"); + if (n.label) + parts.push(" ", path.call(print, "label")); + parts.push(";"); + return (0, lines_1.concat)(parts); + case "LabeledStatement": + return (0, lines_1.concat)([ + path.call(print, "label"), + ":\n", + path.call(print, "body"), + ]); + case "TryStatement": + parts.push("try ", path.call(print, "block")); + if (n.handler) { + parts.push(" ", path.call(print, "handler")); + } + else if (n.handlers) { + path.each(function (handlerPath) { + parts.push(" ", print(handlerPath)); + }, "handlers"); + } + if (n.finalizer) { + parts.push(" finally ", path.call(print, "finalizer")); + } + return (0, lines_1.concat)(parts); + case "CatchClause": + parts.push("catch "); + if (n.param) { + parts.push("(", path.call(print, "param")); + } + if (n.guard) { + // Note: esprima does not recognize conditional catch clauses. + parts.push(" if ", path.call(print, "guard")); + } + if (n.param) { + parts.push(") "); + } + parts.push(path.call(print, "body")); + return (0, lines_1.concat)(parts); + case "ThrowStatement": + return (0, lines_1.concat)(["throw ", path.call(print, "argument"), ";"]); + case "SwitchStatement": + return (0, lines_1.concat)([ + "switch (", + path.call(print, "discriminant"), + ") {\n", + (0, lines_1.fromString)("\n").join(path.map(print, "cases")), + "\n}", + ]); + // Note: ignoring n.lexical because it has no printing consequences. + case "SwitchCase": + if (n.test) + parts.push("case ", path.call(print, "test"), ":"); + else + parts.push("default:"); + if (n.consequent.length > 0) { + parts.push("\n", path + .call(function (consequentPath) { + return printStatementSequence(consequentPath, options, print); + }, "consequent") + .indent(options.tabWidth)); + } + return (0, lines_1.concat)(parts); + case "DebuggerStatement": + return (0, lines_1.fromString)("debugger;"); + // JSX extensions below. + case "JSXAttribute": + parts.push(path.call(print, "name")); + if (n.value) + parts.push("=", path.call(print, "value")); + return (0, lines_1.concat)(parts); + case "JSXIdentifier": + return (0, lines_1.fromString)(n.name, options); + case "JSXNamespacedName": + return (0, lines_1.fromString)(":").join([ + path.call(print, "namespace"), + path.call(print, "name"), + ]); + case "JSXMemberExpression": + return (0, lines_1.fromString)(".").join([ + path.call(print, "object"), + path.call(print, "property"), + ]); + case "JSXSpreadAttribute": + return (0, lines_1.concat)(["{...", path.call(print, "argument"), "}"]); + case "JSXSpreadChild": + return (0, lines_1.concat)(["{...", path.call(print, "expression"), "}"]); + case "JSXExpressionContainer": + return (0, lines_1.concat)(["{", path.call(print, "expression"), "}"]); + case "JSXElement": + case "JSXFragment": { + var openingPropName = "opening" + (n.type === "JSXElement" ? "Element" : "Fragment"); + var closingPropName = "closing" + (n.type === "JSXElement" ? "Element" : "Fragment"); + var openingLines = path.call(print, openingPropName); + if (n[openingPropName].selfClosing) { + (0, tiny_invariant_1.default)(!n[closingPropName], "unexpected " + + closingPropName + + " element in self-closing " + + n.type); + return openingLines; + } + var childLines = (0, lines_1.concat)(path.map(function (childPath) { + var child = childPath.getValue(); + if (namedTypes.Literal.check(child) && + typeof child.value === "string") { + if (/\S/.test(child.value)) { + return child.value.replace(/^\s+/g, ""); + } + else if (/\n/.test(child.value)) { + return "\n"; + } + } + return print(childPath); + }, "children")).indentTail(options.tabWidth); + var closingLines = path.call(print, closingPropName); + return (0, lines_1.concat)([openingLines, childLines, closingLines]); + } + case "JSXOpeningElement": { + parts.push("<", path.call(print, "name")); + var typeDefPart = path.call(print, "typeParameters"); + if (typeDefPart.length) + parts.push(typeDefPart); + var attrParts_1 = []; + path.each(function (attrPath) { + attrParts_1.push(" ", print(attrPath)); + }, "attributes"); + var attrLines = (0, lines_1.concat)(attrParts_1); + var needLineWrap = attrLines.length > 1 || attrLines.getLineLength(1) > options.wrapColumn; + if (needLineWrap) { + attrParts_1.forEach(function (part, i) { + if (part === " ") { + (0, tiny_invariant_1.default)(i % 2 === 0); + attrParts_1[i] = "\n"; + } + }); + attrLines = (0, lines_1.concat)(attrParts_1).indentTail(options.tabWidth); + } + parts.push(attrLines, n.selfClosing ? " />" : ">"); + return (0, lines_1.concat)(parts); + } + case "JSXClosingElement": + return (0, lines_1.concat)([""]); + case "JSXOpeningFragment": + return (0, lines_1.fromString)("<>"); + case "JSXClosingFragment": + return (0, lines_1.fromString)(""); + case "JSXText": + return (0, lines_1.fromString)(n.value, options); + case "JSXEmptyExpression": + return (0, lines_1.fromString)(""); + case "TypeAnnotatedIdentifier": + return (0, lines_1.concat)([ + path.call(print, "annotation"), + " ", + path.call(print, "identifier"), + ]); + case "ClassBody": + if (n.body.length === 0) { + return (0, lines_1.fromString)("{}"); + } + return (0, lines_1.concat)([ + "{\n", + path + .call(function (bodyPath) { return printStatementSequence(bodyPath, options, print); }, "body") + .indent(options.tabWidth), + "\n}", + ]); + case "ClassPropertyDefinition": + parts.push("static ", path.call(print, "definition")); + if (!namedTypes.MethodDefinition.check(n.definition)) + parts.push(";"); + return (0, lines_1.concat)(parts); + case "ClassProperty": { + if (n.declare) { + parts.push("declare "); + } + var access = n.accessibility || n.access; + if (typeof access === "string") { + parts.push(access, " "); + } + if (n.static) { + parts.push("static "); + } + if (n.abstract) { + parts.push("abstract "); + } + if (n.readonly) { + parts.push("readonly "); + } + var key = path.call(print, "key"); + if (n.computed) { + key = (0, lines_1.concat)(["[", key, "]"]); + } + if (n.variance) { + key = (0, lines_1.concat)([printVariance(path, print), key]); + } + parts.push(key); + if (n.optional) { + parts.push("?"); + } + if (n.definite) { + parts.push("!"); + } + if (n.typeAnnotation) { + parts.push(path.call(print, "typeAnnotation")); + } + if (n.value) { + parts.push(" = ", path.call(print, "value")); + } + parts.push(";"); + return (0, lines_1.concat)(parts); + } + case "ClassPrivateProperty": + if (n.static) { + parts.push("static "); + } + parts.push(path.call(print, "key")); + if (n.typeAnnotation) { + parts.push(path.call(print, "typeAnnotation")); + } + if (n.value) { + parts.push(" = ", path.call(print, "value")); + } + parts.push(";"); + return (0, lines_1.concat)(parts); + case "ClassAccessorProperty": { + parts.push.apply(parts, tslib_1.__spreadArray(tslib_1.__spreadArray([], printClassMemberModifiers(n), false), ["accessor "], false)); + if (n.computed) { + parts.push("[", path.call(print, "key"), "]"); + } + else { + parts.push(path.call(print, "key")); + } + if (n.optional) { + parts.push("?"); + } + if (n.definite) { + parts.push("!"); + } + if (n.typeAnnotation) { + parts.push(path.call(print, "typeAnnotation")); + } + if (n.value) { + parts.push(" = ", path.call(print, "value")); + } + parts.push(";"); + return (0, lines_1.concat)(parts); + } + case "ClassDeclaration": + case "ClassExpression": + case "DeclareClass": + if (n.declare) { + parts.push("declare "); + } + if (n.abstract) { + parts.push("abstract "); + } + parts.push("class"); + if (n.id) { + parts.push(" ", path.call(print, "id")); + } + if (n.typeParameters) { + parts.push(path.call(print, "typeParameters")); + } + if (n.superClass) { + // ClassDeclaration and ClassExpression only + parts.push(" extends ", path.call(print, "superClass"), path.call(print, "superTypeParameters")); + } + if (n.extends && n.extends.length > 0) { + // DeclareClass only + parts.push(" extends ", (0, lines_1.fromString)(", ").join(path.map(print, "extends"))); + } + if (n["implements"] && n["implements"].length > 0) { + parts.push(" implements ", (0, lines_1.fromString)(", ").join(path.map(print, "implements"))); + } + parts.push(" ", path.call(print, "body")); + if (n.type === "DeclareClass") { + return printFlowDeclaration(path, parts); + } + else { + return (0, lines_1.concat)(parts); + } + case "TemplateElement": + return (0, lines_1.fromString)(n.value.raw, options).lockIndentTail(); + case "TemplateLiteral": { + var expressions_1 = path.map(print, "expressions"); + parts.push("`"); + path.each(function (childPath) { + var i = childPath.getName(); + parts.push(print(childPath)); + if (i < expressions_1.length) { + parts.push("${", expressions_1[i], "}"); + } + }, "quasis"); + parts.push("`"); + return (0, lines_1.concat)(parts).lockIndentTail(); + } + case "TaggedTemplateExpression": + parts.push(path.call(print, "tag")); + if (n.typeParameters) { + parts.push(path.call(print, "typeParameters")); + } + parts.push(path.call(print, "quasi")); + return (0, lines_1.concat)(parts); + // These types are unprintable because they serve as abstract + // supertypes for other (printable) types. + case "Node": + case "Printable": + case "SourceLocation": + case "Position": + case "Statement": + case "Function": + case "Pattern": + case "Expression": + case "Declaration": + case "Specifier": + case "NamedSpecifier": + case "Comment": // Supertype of Block and Line + case "Flow": // Supertype of all Flow AST node types + case "FlowType": // Supertype of all Flow types + case "FlowPredicate": // Supertype of InferredPredicate and DeclaredPredicate + case "MemberTypeAnnotation": // Flow + case "Type": // Flow + case "TSHasOptionalTypeParameterInstantiation": + case "TSHasOptionalTypeParameters": + case "TSHasOptionalTypeAnnotation": + case "ChainElement": // Supertype of MemberExpression and CallExpression + throw new Error("unprintable type: " + JSON.stringify(n.type)); + case "CommentBlock": // Babel block comment. + case "Block": // Esprima block comment. + return (0, lines_1.concat)(["/*", (0, lines_1.fromString)(n.value, options), "*/"]); + case "CommentLine": // Babel line comment. + case "Line": // Esprima line comment. + return (0, lines_1.concat)(["//", (0, lines_1.fromString)(n.value, options)]); + // Type Annotations for Facebook Flow, typically stripped out or + // transformed away before printing. + case "TypeAnnotation": + if (n.typeAnnotation) { + if (n.typeAnnotation.type !== "FunctionTypeAnnotation") { + parts.push(": "); + } + parts.push(path.call(print, "typeAnnotation")); + return (0, lines_1.concat)(parts); + } + return (0, lines_1.fromString)(""); + case "ExistentialTypeParam": + case "ExistsTypeAnnotation": + return (0, lines_1.fromString)("*", options); + case "EmptyTypeAnnotation": + return (0, lines_1.fromString)("empty", options); + case "AnyTypeAnnotation": + return (0, lines_1.fromString)("any", options); + case "MixedTypeAnnotation": + return (0, lines_1.fromString)("mixed", options); + case "ArrayTypeAnnotation": + return (0, lines_1.concat)([path.call(print, "elementType"), "[]"]); + case "TupleTypeAnnotation": { + var printed_2 = path.map(print, "types"); + var joined = (0, lines_1.fromString)(", ").join(printed_2); + var oneLine_3 = joined.getLineLength(1) <= options.wrapColumn; + if (oneLine_3) { + if (options.arrayBracketSpacing) { + parts.push("[ "); + } + else { + parts.push("["); + } + } + else { + parts.push("[\n"); + } + path.each(function (elemPath) { + var i = elemPath.getName(); + var elem = elemPath.getValue(); + if (!elem) { + // If the array expression ends with a hole, that hole + // will be ignored by the interpreter, but if it ends with + // two (or more) holes, we need to write out two (or more) + // commas so that the resulting code is interpreted with + // both (all) of the holes. + parts.push(","); + } + else { + var lines = printed_2[i]; + if (oneLine_3) { + if (i > 0) + parts.push(" "); + } + else { + lines = lines.indent(options.tabWidth); + } + parts.push(lines); + if (i < n.types.length - 1 || + (!oneLine_3 && util.isTrailingCommaEnabled(options, "arrays"))) + parts.push(","); + if (!oneLine_3) + parts.push("\n"); + } + }, "types"); + if (oneLine_3 && options.arrayBracketSpacing) { + parts.push(" ]"); + } + else { + parts.push("]"); + } + return (0, lines_1.concat)(parts); + } + case "BooleanTypeAnnotation": + return (0, lines_1.fromString)("boolean", options); + case "BooleanLiteralTypeAnnotation": + (0, tiny_invariant_1.default)(typeof n.value === "boolean"); + return (0, lines_1.fromString)("" + n.value, options); + case "InterfaceTypeAnnotation": + parts.push("interface"); + if (n.extends && n.extends.length > 0) { + parts.push(" extends ", (0, lines_1.fromString)(", ").join(path.map(print, "extends"))); + } + parts.push(" ", path.call(print, "body")); + return (0, lines_1.concat)(parts); + case "DeclareFunction": + return printFlowDeclaration(path, [ + "function ", + path.call(print, "id"), + ";", + ]); + case "DeclareModule": + return printFlowDeclaration(path, [ + "module ", + path.call(print, "id"), + " ", + path.call(print, "body"), + ]); + case "DeclareModuleExports": + return printFlowDeclaration(path, [ + "module.exports", + path.call(print, "typeAnnotation"), + ]); + case "DeclareVariable": + return printFlowDeclaration(path, ["var ", path.call(print, "id"), ";"]); + case "DeclareExportDeclaration": + case "DeclareExportAllDeclaration": + return (0, lines_1.concat)(["declare ", printExportDeclaration(path, options, print)]); + case "EnumDeclaration": + return (0, lines_1.concat)([ + "enum ", + path.call(print, "id"), + path.call(print, "body"), + ]); + case "EnumBooleanBody": + case "EnumNumberBody": + case "EnumStringBody": + case "EnumSymbolBody": { + if (n.type === "EnumSymbolBody" || n.explicitType) { + parts.push(" of ", + // EnumBooleanBody => boolean, etc. + n.type.slice(4, -4).toLowerCase()); + } + parts.push(" {\n", (0, lines_1.fromString)("\n") + .join(path.map(print, "members")) + .indent(options.tabWidth), "\n}"); + return (0, lines_1.concat)(parts); + } + case "EnumDefaultedMember": + return (0, lines_1.concat)([path.call(print, "id"), ","]); + case "EnumBooleanMember": + case "EnumNumberMember": + case "EnumStringMember": + return (0, lines_1.concat)([ + path.call(print, "id"), + " = ", + path.call(print, "init"), + ",", + ]); + case "InferredPredicate": + return (0, lines_1.fromString)("%checks", options); + case "DeclaredPredicate": + return (0, lines_1.concat)(["%checks(", path.call(print, "value"), ")"]); + case "FunctionTypeAnnotation": { + // FunctionTypeAnnotation is ambiguous: + // declare function(a: B): void; OR + // const A: (a: B) => void; + var parent = path.getParentNode(0); + var isArrowFunctionTypeAnnotation = !(namedTypes.ObjectTypeCallProperty.check(parent) || + (namedTypes.ObjectTypeInternalSlot.check(parent) && parent.method) || + namedTypes.DeclareFunction.check(path.getParentNode(2))); + var needsColon = isArrowFunctionTypeAnnotation && + !namedTypes.FunctionTypeParam.check(parent) && + !namedTypes.TypeAlias.check(parent); + if (needsColon) { + parts.push(": "); + } + var hasTypeParameters = !!n.typeParameters; + var needsParens = hasTypeParameters || n.params.length !== 1 || n.params[0].name; + parts.push(hasTypeParameters ? path.call(print, "typeParameters") : "", needsParens ? "(" : "", printFunctionParams(path, options, print), needsParens ? ")" : ""); + // The returnType is not wrapped in a TypeAnnotation, so the colon + // needs to be added separately. + if (n.returnType) { + parts.push(isArrowFunctionTypeAnnotation ? " => " : ": ", path.call(print, "returnType")); + } + return (0, lines_1.concat)(parts); + } + case "FunctionTypeParam": { + var name = path.call(print, "name"); + parts.push(name); + if (n.optional) { + parts.push("?"); + } + if (name.infos[0].line) { + parts.push(": "); + } + parts.push(path.call(print, "typeAnnotation")); + return (0, lines_1.concat)(parts); + } + case "GenericTypeAnnotation": + return (0, lines_1.concat)([ + path.call(print, "id"), + path.call(print, "typeParameters"), + ]); + case "DeclareInterface": + parts.push("declare "); + // Fall through to InterfaceDeclaration... + case "InterfaceDeclaration": + case "TSInterfaceDeclaration": + if (n.declare) { + parts.push("declare "); + } + parts.push("interface ", path.call(print, "id"), path.call(print, "typeParameters"), " "); + if (n["extends"] && n["extends"].length > 0) { + parts.push("extends ", (0, lines_1.fromString)(", ").join(path.map(print, "extends")), " "); + } + if (n.body) { + parts.push(path.call(print, "body")); + } + return (0, lines_1.concat)(parts); + case "ClassImplements": + case "InterfaceExtends": + return (0, lines_1.concat)([ + path.call(print, "id"), + path.call(print, "typeParameters"), + ]); + case "IntersectionTypeAnnotation": + return (0, lines_1.fromString)(" & ").join(path.map(print, "types")); + case "NullableTypeAnnotation": + return (0, lines_1.concat)(["?", path.call(print, "typeAnnotation")]); + case "NullLiteralTypeAnnotation": + return (0, lines_1.fromString)("null", options); + case "ThisTypeAnnotation": + return (0, lines_1.fromString)("this", options); + case "NumberTypeAnnotation": + return (0, lines_1.fromString)("number", options); + case "ObjectTypeCallProperty": + return path.call(print, "value"); + case "ObjectTypeIndexer": + if (n.static) { + parts.push("static "); + } + parts.push(printVariance(path, print), "["); + if (n.id) { + parts.push(path.call(print, "id"), ": "); + } + parts.push(path.call(print, "key"), "]: ", path.call(print, "value")); + return (0, lines_1.concat)(parts); + case "ObjectTypeProperty": + return (0, lines_1.concat)([ + printVariance(path, print), + path.call(print, "key"), + n.optional ? "?" : "", + ": ", + path.call(print, "value"), + ]); + case "ObjectTypeInternalSlot": + return (0, lines_1.concat)([ + n.static ? "static " : "", + "[[", + path.call(print, "id"), + "]]", + n.optional ? "?" : "", + n.value.type !== "FunctionTypeAnnotation" ? ": " : "", + path.call(print, "value"), + ]); + case "QualifiedTypeIdentifier": + return (0, lines_1.concat)([ + path.call(print, "qualification"), + ".", + path.call(print, "id"), + ]); + case "StringLiteralTypeAnnotation": + return (0, lines_1.fromString)(nodeStr(n.value, options), options); + case "NumberLiteralTypeAnnotation": + case "NumericLiteralTypeAnnotation": + (0, tiny_invariant_1.default)(typeof n.value === "number"); + return (0, lines_1.fromString)(JSON.stringify(n.value), options); + case "BigIntLiteralTypeAnnotation": + return (0, lines_1.fromString)(n.raw, options); + case "StringTypeAnnotation": + return (0, lines_1.fromString)("string", options); + case "DeclareTypeAlias": + parts.push("declare "); + // Fall through to TypeAlias... + case "TypeAlias": + return (0, lines_1.concat)([ + "type ", + path.call(print, "id"), + path.call(print, "typeParameters"), + " = ", + path.call(print, "right"), + ";", + ]); + case "DeclareOpaqueType": + parts.push("declare "); + // Fall through to OpaqueType... + case "OpaqueType": + parts.push("opaque type ", path.call(print, "id"), path.call(print, "typeParameters")); + if (n["supertype"]) { + parts.push(": ", path.call(print, "supertype")); + } + if (n["impltype"]) { + parts.push(" = ", path.call(print, "impltype")); + } + parts.push(";"); + return (0, lines_1.concat)(parts); + case "TypeCastExpression": + return (0, lines_1.concat)([ + "(", + path.call(print, "expression"), + path.call(print, "typeAnnotation"), + ")", + ]); + case "TypeParameterDeclaration": + case "TypeParameterInstantiation": + return (0, lines_1.concat)([ + "<", + (0, lines_1.fromString)(", ").join(path.map(print, "params")), + ">", + ]); + case "Variance": + if (n.kind === "plus") { + return (0, lines_1.fromString)("+"); + } + if (n.kind === "minus") { + return (0, lines_1.fromString)("-"); + } + return (0, lines_1.fromString)(""); + case "TypeParameter": + if (n.variance) { + parts.push(printVariance(path, print)); + } + parts.push(path.call(print, "name")); + if (n.bound) { + parts.push(path.call(print, "bound")); + } + if (n["default"]) { + parts.push("=", path.call(print, "default")); + } + return (0, lines_1.concat)(parts); + case "TypeofTypeAnnotation": + return (0, lines_1.concat)([ + (0, lines_1.fromString)("typeof ", options), + path.call(print, "argument"), + ]); + case "IndexedAccessType": + case "OptionalIndexedAccessType": + return (0, lines_1.concat)([ + path.call(print, "objectType"), + n.optional ? "?." : "", + "[", + path.call(print, "indexType"), + "]", + ]); + case "UnionTypeAnnotation": + return (0, lines_1.fromString)(" | ").join(path.map(print, "types")); + case "VoidTypeAnnotation": + return (0, lines_1.fromString)("void", options); + case "NullTypeAnnotation": + return (0, lines_1.fromString)("null", options); + case "SymbolTypeAnnotation": + return (0, lines_1.fromString)("symbol", options); + case "BigIntTypeAnnotation": + return (0, lines_1.fromString)("bigint", options); + // Type Annotations for TypeScript (when using Babylon as parser) + case "TSType": + throw new Error("unprintable type: " + JSON.stringify(n.type)); + case "TSNumberKeyword": + return (0, lines_1.fromString)("number", options); + case "TSBigIntKeyword": + return (0, lines_1.fromString)("bigint", options); + case "TSObjectKeyword": + return (0, lines_1.fromString)("object", options); + case "TSBooleanKeyword": + return (0, lines_1.fromString)("boolean", options); + case "TSStringKeyword": + return (0, lines_1.fromString)("string", options); + case "TSSymbolKeyword": + return (0, lines_1.fromString)("symbol", options); + case "TSAnyKeyword": + return (0, lines_1.fromString)("any", options); + case "TSVoidKeyword": + return (0, lines_1.fromString)("void", options); + case "TSIntrinsicKeyword": + return (0, lines_1.fromString)("intrinsic", options); + case "TSThisType": + return (0, lines_1.fromString)("this", options); + case "TSNullKeyword": + return (0, lines_1.fromString)("null", options); + case "TSUndefinedKeyword": + return (0, lines_1.fromString)("undefined", options); + case "TSUnknownKeyword": + return (0, lines_1.fromString)("unknown", options); + case "TSNeverKeyword": + return (0, lines_1.fromString)("never", options); + case "TSArrayType": + return (0, lines_1.concat)([path.call(print, "elementType"), "[]"]); + case "TSLiteralType": + return path.call(print, "literal"); + case "TSUnionType": + return (0, lines_1.fromString)(" | ").join(path.map(print, "types")); + case "TSIntersectionType": + return (0, lines_1.fromString)(" & ").join(path.map(print, "types")); + case "TSConditionalType": + parts.push(path.call(print, "checkType"), " extends ", path.call(print, "extendsType"), " ? ", path.call(print, "trueType"), " : ", path.call(print, "falseType")); + return (0, lines_1.concat)(parts); + case "TSInferType": + parts.push("infer ", path.call(print, "typeParameter")); + return (0, lines_1.concat)(parts); + case "TSParenthesizedType": + return (0, lines_1.concat)(["(", path.call(print, "typeAnnotation"), ")"]); + case "TSFunctionType": + return (0, lines_1.concat)([ + path.call(print, "typeParameters"), + "(", + printFunctionParams(path, options, print), + ") => ", + path.call(print, "typeAnnotation", "typeAnnotation"), + ]); + case "TSConstructorType": + return (0, lines_1.concat)([ + "new ", + path.call(print, "typeParameters"), + "(", + printFunctionParams(path, options, print), + ") => ", + path.call(print, "typeAnnotation", "typeAnnotation"), + ]); + case "TSMappedType": { + parts.push(n.readonly ? "readonly " : "", "[", path.call(print, "typeParameter"), "]", n.optional ? "?" : ""); + if (n.typeAnnotation) { + parts.push(": ", path.call(print, "typeAnnotation"), ";"); + } + return (0, lines_1.concat)(["{\n", (0, lines_1.concat)(parts).indent(options.tabWidth), "\n}"]); + } + case "TSTupleType": + return (0, lines_1.concat)([ + "[", + (0, lines_1.fromString)(", ").join(path.map(print, "elementTypes")), + "]", + ]); + case "TSNamedTupleMember": + parts.push(path.call(print, "label")); + if (n.optional) { + parts.push("?"); + } + parts.push(": ", path.call(print, "elementType")); + return (0, lines_1.concat)(parts); + case "TSRestType": + return (0, lines_1.concat)(["...", path.call(print, "typeAnnotation")]); + case "TSOptionalType": + return (0, lines_1.concat)([path.call(print, "typeAnnotation"), "?"]); + case "TSIndexedAccessType": + return (0, lines_1.concat)([ + path.call(print, "objectType"), + "[", + path.call(print, "indexType"), + "]", + ]); + case "TSTypeOperator": + return (0, lines_1.concat)([ + path.call(print, "operator"), + " ", + path.call(print, "typeAnnotation"), + ]); + case "TSTypeLiteral": { + var members = (0, lines_1.fromString)("\n").join(path.map(print, "members").map(function (member) { + if (lastNonSpaceCharacter(member) !== ";") { + return member.concat(";"); + } + return member; + })); + if (members.isEmpty()) { + return (0, lines_1.fromString)("{}", options); + } + parts.push("{\n", members.indent(options.tabWidth), "\n}"); + return (0, lines_1.concat)(parts); + } + case "TSEnumMember": + parts.push(path.call(print, "id")); + if (n.initializer) { + parts.push(" = ", path.call(print, "initializer")); + } + return (0, lines_1.concat)(parts); + case "TSTypeQuery": + return (0, lines_1.concat)(["typeof ", path.call(print, "exprName")]); + case "TSParameterProperty": + if (n.accessibility) { + parts.push(n.accessibility, " "); + } + if (n.export) { + parts.push("export "); + } + if (n.static) { + parts.push("static "); + } + if (n.readonly) { + parts.push("readonly "); + } + parts.push(path.call(print, "parameter")); + return (0, lines_1.concat)(parts); + case "TSTypeReference": + return (0, lines_1.concat)([ + path.call(print, "typeName"), + path.call(print, "typeParameters"), + ]); + case "TSQualifiedName": + return (0, lines_1.concat)([path.call(print, "left"), ".", path.call(print, "right")]); + case "TSAsExpression": + case "TSSatisfiesExpression": { + var expression = path.call(print, "expression"); + parts.push(expression, n.type === "TSSatisfiesExpression" ? " satisfies " : " as ", path.call(print, "typeAnnotation")); + return (0, lines_1.concat)(parts); + } + case "TSTypeCastExpression": + return (0, lines_1.concat)([ + path.call(print, "expression"), + path.call(print, "typeAnnotation"), + ]); + case "TSNonNullExpression": + return (0, lines_1.concat)([path.call(print, "expression"), "!"]); + case "TSTypeAnnotation": + return (0, lines_1.concat)([": ", path.call(print, "typeAnnotation")]); + case "TSIndexSignature": + return (0, lines_1.concat)([ + n.readonly ? "readonly " : "", + "[", + path.map(print, "parameters"), + "]", + path.call(print, "typeAnnotation"), + ]); + case "TSPropertySignature": + parts.push(printVariance(path, print), n.readonly ? "readonly " : ""); + if (n.computed) { + parts.push("[", path.call(print, "key"), "]"); + } + else { + parts.push(path.call(print, "key")); + } + parts.push(n.optional ? "?" : "", path.call(print, "typeAnnotation")); + return (0, lines_1.concat)(parts); + case "TSMethodSignature": + if (n.kind === "get") { + parts.push("get "); + } + else if (n.kind === "set") { + parts.push("set "); + } + if (n.computed) { + parts.push("[", path.call(print, "key"), "]"); + } + else { + parts.push(path.call(print, "key")); + } + if (n.optional) { + parts.push("?"); + } + parts.push(path.call(print, "typeParameters"), "(", printFunctionParams(path, options, print), ")", path.call(print, "typeAnnotation")); + return (0, lines_1.concat)(parts); + case "TSTypePredicate": + if (n.asserts) { + parts.push("asserts "); + } + parts.push(path.call(print, "parameterName")); + if (n.typeAnnotation) { + parts.push(" is ", path.call(print, "typeAnnotation", "typeAnnotation")); + } + return (0, lines_1.concat)(parts); + case "TSCallSignatureDeclaration": + return (0, lines_1.concat)([ + path.call(print, "typeParameters"), + "(", + printFunctionParams(path, options, print), + ")", + path.call(print, "typeAnnotation"), + ]); + case "TSConstructSignatureDeclaration": + if (n.typeParameters) { + parts.push("new", path.call(print, "typeParameters")); + } + else { + parts.push("new "); + } + parts.push("(", printFunctionParams(path, options, print), ")", path.call(print, "typeAnnotation")); + return (0, lines_1.concat)(parts); + case "TSTypeAliasDeclaration": + return (0, lines_1.concat)([ + n.declare ? "declare " : "", + "type ", + path.call(print, "id"), + path.call(print, "typeParameters"), + " = ", + path.call(print, "typeAnnotation"), + ";", + ]); + case "TSTypeParameter": { + parts.push(path.call(print, "name")); + // ambiguous because of TSMappedType + var parent = path.getParentNode(0); + var isInMappedType = namedTypes.TSMappedType.check(parent); + if (n.constraint) { + parts.push(isInMappedType ? " in " : " extends ", path.call(print, "constraint")); + } + if (n["default"]) { + parts.push(" = ", path.call(print, "default")); + } + return (0, lines_1.concat)(parts); + } + case "TSTypeAssertion": { + parts.push("<", path.call(print, "typeAnnotation"), "> ", path.call(print, "expression")); + return (0, lines_1.concat)(parts); + } + case "TSTypeParameterDeclaration": + case "TSTypeParameterInstantiation": + return (0, lines_1.concat)([ + "<", + (0, lines_1.fromString)(", ").join(path.map(print, "params")), + ">", + ]); + case "TSEnumDeclaration": { + parts.push(n.declare ? "declare " : "", n.const ? "const " : "", "enum ", path.call(print, "id")); + var memberLines = (0, lines_1.fromString)(",\n").join(path.map(print, "members")); + if (memberLines.isEmpty()) { + parts.push(" {}"); + } + else { + parts.push(" {\n", memberLines.indent(options.tabWidth), "\n}"); + } + return (0, lines_1.concat)(parts); + } + case "TSExpressionWithTypeArguments": + return (0, lines_1.concat)([ + path.call(print, "expression"), + path.call(print, "typeParameters"), + ]); + case "TSInterfaceBody": { + var lines = (0, lines_1.fromString)("\n").join(path.map(print, "body").map(function (element) { + if (lastNonSpaceCharacter(element) !== ";") { + return element.concat(";"); + } + return element; + })); + if (lines.isEmpty()) { + return (0, lines_1.fromString)("{}", options); + } + return (0, lines_1.concat)(["{\n", lines.indent(options.tabWidth), "\n}"]); + } + case "TSImportType": + parts.push("import(", path.call(print, "argument"), ")"); + if (n.qualifier) { + parts.push(".", path.call(print, "qualifier")); + } + if (n.typeParameters) { + parts.push(path.call(print, "typeParameters")); + } + return (0, lines_1.concat)(parts); + case "TSImportEqualsDeclaration": + if (n.isExport) { + parts.push("export "); + } + parts.push("import ", path.call(print, "id"), " = ", path.call(print, "moduleReference")); + return maybeAddSemicolon((0, lines_1.concat)(parts)); + case "TSExternalModuleReference": + return (0, lines_1.concat)(["require(", path.call(print, "expression"), ")"]); + case "TSModuleDeclaration": { + var parent = path.getParentNode(); + if (parent.type === "TSModuleDeclaration") { + parts.push("."); + } + else { + if (n.declare) { + parts.push("declare "); + } + if (!n.global) { + var isExternal = n.id.type === "StringLiteral" || + (n.id.type === "Literal" && typeof n.id.value === "string"); + if (isExternal) { + parts.push("module "); + } + else if (n.loc && n.loc.lines && n.id.loc) { + var prefix = n.loc.lines.sliceString(n.loc.start, n.id.loc.start); + // These keywords are fundamentally ambiguous in the + // Babylon parser, and not reflected in the AST, so + // the best we can do is to match the original code, + // when possible. + if (prefix.indexOf("module") >= 0) { + parts.push("module "); + } + else { + parts.push("namespace "); + } + } + else { + parts.push("namespace "); + } + } + } + parts.push(path.call(print, "id")); + if (n.body) { + parts.push(" "); + parts.push(path.call(print, "body")); + } + return (0, lines_1.concat)(parts); + } + case "TSModuleBlock": { + var naked = path.call(function (bodyPath) { return printStatementSequence(bodyPath, options, print); }, "body"); + if (naked.isEmpty()) { + parts.push("{}"); + } + else { + parts.push("{\n", naked.indent(options.tabWidth), "\n}"); + } + return (0, lines_1.concat)(parts); + } + case "TSInstantiationExpression": { + parts.push(path.call(print, "expression"), path.call(print, "typeParameters")); + return (0, lines_1.concat)(parts); + } + // https://github.com/babel/babel/pull/10148 + case "V8IntrinsicIdentifier": + return (0, lines_1.concat)(["%", path.call(print, "name")]); + // https://github.com/babel/babel/pull/13191 + case "TopicReference": + return (0, lines_1.fromString)("#"); + // Unhandled types below. If encountered, nodes of these types should + // be either left alone or desugared into AST types that are fully + // supported by the pretty-printer. + case "ClassHeritage": // TODO + case "ComprehensionBlock": // TODO + case "ComprehensionExpression": // TODO + case "Glob": // TODO + case "GeneratorExpression": // TODO + case "LetStatement": // TODO + case "LetExpression": // TODO + case "GraphExpression": // TODO + case "GraphIndexExpression": // TODO + case "XMLDefaultDeclaration": + case "XMLAnyName": + case "XMLQualifiedIdentifier": + case "XMLFunctionQualifiedIdentifier": + case "XMLAttributeSelector": + case "XMLFilterExpression": + case "XML": + case "XMLElement": + case "XMLList": + case "XMLEscape": + case "XMLText": + case "XMLStartTag": + case "XMLEndTag": + case "XMLPointTag": + case "XMLName": + case "XMLAttribute": + case "XMLCdata": + case "XMLComment": + case "XMLProcessingInstruction": + default: + debugger; + throw new Error("unknown type: " + JSON.stringify(n.type)); + } +} +function printDecorators(path, printPath) { + var parts = []; + var node = path.getValue(); + if (node.decorators && + node.decorators.length > 0 && + // If the parent node is an export declaration, it will be + // responsible for printing node.decorators. + !util.getParentExportDeclaration(path)) { + path.each(function (decoratorPath) { + parts.push(printPath(decoratorPath), "\n"); + }, "decorators"); + } + else if (util.isExportDeclaration(node) && + node.declaration && + node.declaration.decorators) { + // Export declarations are responsible for printing any decorators + // that logically apply to node.declaration. + path.each(function (decoratorPath) { + parts.push(printPath(decoratorPath), "\n"); + }, "declaration", "decorators"); + } + return (0, lines_1.concat)(parts); +} +function printStatementSequence(path, options, print) { + var filtered = []; + var sawComment = false; + var sawStatement = false; + path.each(function (stmtPath) { + var stmt = stmtPath.getValue(); + // Just in case the AST has been modified to contain falsy + // "statements," it's safer simply to skip them. + if (!stmt) { + return; + } + // Skip printing EmptyStatement nodes to avoid leaving stray + // semicolons lying around. + if (stmt.type === "EmptyStatement" && + !(stmt.comments && stmt.comments.length > 0)) { + return; + } + if (namedTypes.Comment.check(stmt)) { + // The pretty printer allows a dangling Comment node to act as + // a Statement when the Comment can't be attached to any other + // non-Comment node in the tree. + sawComment = true; + } + else if (namedTypes.Statement.check(stmt)) { + sawStatement = true; + } + else { + // When the pretty printer encounters a string instead of an + // AST node, it just prints the string. This behavior can be + // useful for fine-grained formatting decisions like inserting + // blank lines. + isString.assert(stmt); + } + // We can't hang onto stmtPath outside of this function, because + // it's just a reference to a mutable FastPath object, so we have + // to go ahead and print it here. + filtered.push({ + node: stmt, + printed: print(stmtPath), + }); + }); + if (sawComment) { + (0, tiny_invariant_1.default)(sawStatement === false, "Comments may appear as statements in otherwise empty statement " + + "lists, but may not coexist with non-Comment nodes."); + } + var prevTrailingSpace = null; + var len = filtered.length; + var parts = []; + filtered.forEach(function (info, i) { + var printed = info.printed; + var stmt = info.node; + var multiLine = printed.length > 1; + var notFirst = i > 0; + var notLast = i < len - 1; + var leadingSpace; + var trailingSpace; + var lines = stmt && stmt.loc && stmt.loc.lines; + var trueLoc = lines && options.reuseWhitespace && util.getTrueLoc(stmt, lines); + if (notFirst) { + if (trueLoc) { + var beforeStart = lines.skipSpaces(trueLoc.start, true); + var beforeStartLine = beforeStart ? beforeStart.line : 1; + var leadingGap = trueLoc.start.line - beforeStartLine; + leadingSpace = Array(leadingGap + 1).join("\n"); + } + else { + leadingSpace = multiLine ? "\n\n" : "\n"; + } + } + else { + leadingSpace = ""; + } + if (notLast) { + if (trueLoc) { + var afterEnd = lines.skipSpaces(trueLoc.end); + var afterEndLine = afterEnd ? afterEnd.line : lines.length; + var trailingGap = afterEndLine - trueLoc.end.line; + trailingSpace = Array(trailingGap + 1).join("\n"); + } + else { + trailingSpace = multiLine ? "\n\n" : "\n"; + } + } + else { + trailingSpace = ""; + } + parts.push(maxSpace(prevTrailingSpace, leadingSpace), printed); + if (notLast) { + prevTrailingSpace = trailingSpace; + } + else if (trailingSpace) { + parts.push(trailingSpace); + } + }); + return (0, lines_1.concat)(parts); +} +function maxSpace(s1, s2) { + if (!s1 && !s2) { + return (0, lines_1.fromString)(""); + } + if (!s1) { + return (0, lines_1.fromString)(s2); + } + if (!s2) { + return (0, lines_1.fromString)(s1); + } + var spaceLines1 = (0, lines_1.fromString)(s1); + var spaceLines2 = (0, lines_1.fromString)(s2); + if (spaceLines2.length > spaceLines1.length) { + return spaceLines2; + } + return spaceLines1; +} +function printClassMemberModifiers(node) { + var parts = []; + if (node.declare) { + parts.push("declare "); + } + var access = node.accessibility || node.access; + if (typeof access === "string") { + parts.push(access, " "); + } + if (node.static) { + parts.push("static "); + } + if (node.override) { + parts.push("override "); + } + if (node.abstract) { + parts.push("abstract "); + } + if (node.readonly) { + parts.push("readonly "); + } + return parts; +} +function printMethod(path, options, print) { + var node = path.getNode(); + var kind = node.kind; + var parts = []; + var nodeValue = node.value; + if (!namedTypes.FunctionExpression.check(nodeValue)) { + nodeValue = node; + } + parts.push.apply(parts, printClassMemberModifiers(node)); + if (nodeValue.async) { + parts.push("async "); + } + if (nodeValue.generator) { + parts.push("*"); + } + if (kind === "get" || kind === "set") { + parts.push(kind, " "); + } + var key = path.call(print, "key"); + if (node.computed) { + key = (0, lines_1.concat)(["[", key, "]"]); + } + parts.push(key); + if (node.optional) { + parts.push("?"); + } + if (node === nodeValue) { + parts.push(path.call(print, "typeParameters"), "(", printFunctionParams(path, options, print), ")", path.call(print, "returnType")); + if (node.body) { + parts.push(" ", path.call(print, "body")); + } + else { + parts.push(";"); + } + } + else { + parts.push(path.call(print, "value", "typeParameters"), "(", path.call(function (valuePath) { return printFunctionParams(valuePath, options, print); }, "value"), ")", path.call(print, "value", "returnType")); + if (nodeValue.body) { + parts.push(" ", path.call(print, "value", "body")); + } + else { + parts.push(";"); + } + } + return (0, lines_1.concat)(parts); +} +function printArgumentsList(path, options, print) { + var printed = path.map(print, "arguments"); + var trailingComma = util.isTrailingCommaEnabled(options, "parameters"); + var joined = (0, lines_1.fromString)(", ").join(printed); + if (joined.getLineLength(1) > options.wrapColumn) { + joined = (0, lines_1.fromString)(",\n").join(printed); + return (0, lines_1.concat)([ + "(\n", + joined.indent(options.tabWidth), + trailingComma ? ",\n)" : "\n)", + ]); + } + return (0, lines_1.concat)(["(", joined, ")"]); +} +function printFunctionParams(path, options, print) { + var fun = path.getValue(); + var params; + var printed = []; + if (fun.params) { + params = fun.params; + printed = path.map(print, "params"); + } + else if (fun.parameters) { + params = fun.parameters; + printed = path.map(print, "parameters"); + } + if (fun.defaults) { + path.each(function (defExprPath) { + var i = defExprPath.getName(); + var p = printed[i]; + if (p && defExprPath.getValue()) { + printed[i] = (0, lines_1.concat)([p, " = ", print(defExprPath)]); + } + }, "defaults"); + } + if (fun.rest) { + printed.push((0, lines_1.concat)(["...", path.call(print, "rest")])); + } + var joined = (0, lines_1.fromString)(", ").join(printed); + if (joined.length > 1 || joined.getLineLength(1) > options.wrapColumn) { + joined = (0, lines_1.fromString)(",\n").join(printed); + if (util.isTrailingCommaEnabled(options, "parameters") && + !fun.rest && + params[params.length - 1].type !== "RestElement") { + joined = (0, lines_1.concat)([joined, ",\n"]); + } + else { + joined = (0, lines_1.concat)([joined, "\n"]); + } + return (0, lines_1.concat)(["\n", joined.indent(options.tabWidth)]); + } + return joined; +} +function maybePrintImportAssertions(path, options, print) { + var n = path.getValue(); + if (n.assertions && n.assertions.length > 0) { + var parts = [" assert {"]; + var printed = path.map(print, "assertions"); + var flat = (0, lines_1.fromString)(", ").join(printed); + if (flat.length > 1 || flat.getLineLength(1) > options.wrapColumn) { + parts.push("\n", (0, lines_1.fromString)(",\n").join(printed).indent(options.tabWidth), "\n}"); + } + else { + parts.push(" ", flat, " }"); + } + return (0, lines_1.concat)(parts); + } + return (0, lines_1.fromString)(""); +} +function printExportDeclaration(path, options, print) { + var decl = path.getValue(); + var parts = ["export "]; + if (decl.exportKind && decl.exportKind === "type") { + if (!decl.declaration) { + parts.push("type "); + } + } + var shouldPrintSpaces = options.objectCurlySpacing; + namedTypes.Declaration.assert(decl); + if (decl["default"] || decl.type === "ExportDefaultDeclaration") { + parts.push("default "); + } + if (decl.declaration) { + parts.push(path.call(print, "declaration")); + } + else if (decl.specifiers) { + if (decl.specifiers.length === 1 && + decl.specifiers[0].type === "ExportBatchSpecifier") { + parts.push("*"); + } + else if (decl.specifiers.length === 0) { + parts.push("{}"); + } + else if (decl.specifiers[0].type === "ExportDefaultSpecifier" || + decl.specifiers[0].type === "ExportNamespaceSpecifier") { + var unbracedSpecifiers_2 = []; + var bracedSpecifiers_2 = []; + path.each(function (specifierPath) { + var spec = specifierPath.getValue(); + if (spec.type === "ExportDefaultSpecifier" || + spec.type === "ExportNamespaceSpecifier") { + unbracedSpecifiers_2.push(print(specifierPath)); + } + else { + bracedSpecifiers_2.push(print(specifierPath)); + } + }, "specifiers"); + unbracedSpecifiers_2.forEach(function (lines, i) { + if (i > 0) { + parts.push(", "); + } + parts.push(lines); + }); + if (bracedSpecifiers_2.length > 0) { + var lines_2 = (0, lines_1.fromString)(", ").join(bracedSpecifiers_2); + if (lines_2.getLineLength(1) > options.wrapColumn) { + lines_2 = (0, lines_1.concat)([ + (0, lines_1.fromString)(",\n").join(bracedSpecifiers_2).indent(options.tabWidth), + ",", + ]); + } + if (unbracedSpecifiers_2.length > 0) { + parts.push(", "); + } + if (lines_2.length > 1) { + parts.push("{\n", lines_2, "\n}"); + } + else if (options.objectCurlySpacing) { + parts.push("{ ", lines_2, " }"); + } + else { + parts.push("{", lines_2, "}"); + } + } + } + else { + parts.push(shouldPrintSpaces ? "{ " : "{", (0, lines_1.fromString)(", ").join(path.map(print, "specifiers")), shouldPrintSpaces ? " }" : "}"); + } + if (decl.source) { + parts.push(" from ", path.call(print, "source"), maybePrintImportAssertions(path, options, print)); + } + } + var lines = (0, lines_1.concat)(parts); + if (lastNonSpaceCharacter(lines) !== ";" && + !(decl.declaration && + (decl.declaration.type === "FunctionDeclaration" || + decl.declaration.type === "ClassDeclaration" || + decl.declaration.type === "TSModuleDeclaration" || + decl.declaration.type === "TSInterfaceDeclaration" || + decl.declaration.type === "TSEnumDeclaration"))) { + lines = (0, lines_1.concat)([lines, ";"]); + } + return lines; +} +function printFlowDeclaration(path, parts) { + var parentExportDecl = util.getParentExportDeclaration(path); + if (parentExportDecl) { + (0, tiny_invariant_1.default)(parentExportDecl.type === "DeclareExportDeclaration"); + } + else { + // If the parent node has type DeclareExportDeclaration, then it + // will be responsible for printing the "declare" token. Otherwise + // it needs to be printed with this non-exported declaration node. + parts.unshift("declare "); + } + return (0, lines_1.concat)(parts); +} +function printVariance(path, print) { + return path.call(function (variancePath) { + var value = variancePath.getValue(); + if (value) { + if (value === "plus") { + return (0, lines_1.fromString)("+"); + } + if (value === "minus") { + return (0, lines_1.fromString)("-"); + } + return print(variancePath); + } + return (0, lines_1.fromString)(""); + }, "variance"); +} +function adjustClause(clause, options) { + if (clause.length > 1) + return (0, lines_1.concat)([" ", clause]); + return (0, lines_1.concat)(["\n", maybeAddSemicolon(clause).indent(options.tabWidth)]); +} +function lastNonSpaceCharacter(lines) { + var pos = lines.lastPos(); + do { + var ch = lines.charAt(pos); + if (/\S/.test(ch)) + return ch; + } while (lines.prevPos(pos)); +} +function endsWithBrace(lines) { + return lastNonSpaceCharacter(lines) === "}"; +} +function swapQuotes(str) { + return str.replace(/['"]/g, function (m) { return (m === '"' ? "'" : '"'); }); +} +function getPossibleRaw(node) { + var value = types.getFieldValue(node, "value"); + var extra = types.getFieldValue(node, "extra"); + if (extra && typeof extra.raw === "string" && value == extra.rawValue) { + return extra.raw; + } + if (node.type === "Literal") { + var raw = node.raw; + if (typeof raw === "string" && value == raw) { + return raw; + } + } +} +function jsSafeStringify(str) { + return JSON.stringify(str).replace(/[\u2028\u2029]/g, function (m) { + return "\\u" + m.charCodeAt(0).toString(16); + }); +} +function nodeStr(str, options) { + isString.assert(str); + switch (options.quote) { + case "auto": { + var double = jsSafeStringify(str); + var single = swapQuotes(jsSafeStringify(swapQuotes(str))); + return double.length > single.length ? single : double; + } + case "single": + return swapQuotes(jsSafeStringify(swapQuotes(str))); + case "double": + default: + return jsSafeStringify(str); + } +} +function maybeAddSemicolon(lines) { + var eoc = lastNonSpaceCharacter(lines); + if (!eoc || "\n};".indexOf(eoc) < 0) + return (0, lines_1.concat)([lines, ";"]); + return lines; +} diff --git a/tools/ui/node_modules/recast/lib/util.d.ts b/tools/ui/node_modules/recast/lib/util.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1d2b6e1148c002b4fe3d4dfdd860426b95e720e2 --- /dev/null +++ b/tools/ui/node_modules/recast/lib/util.d.ts @@ -0,0 +1,18 @@ +export declare function getLineTerminator(): any; +export declare function isBrowser(): boolean; +export declare function getOption(options: any, key: any, defaultValue: any): any; +export declare function getUnionOfKeys(...args: any[]): any; +export declare function comparePos(pos1: any, pos2: any): number; +export declare function copyPos(pos: any): { + line: any; + column: any; +}; +export declare function composeSourceMaps(formerMap: any, latterMap: any): any; +export declare function getTrueLoc(node: any, lines: any): { + start: any; + end: any; +} | null; +export declare function fixFaultyLocations(node: any, lines: any): void; +export declare function isExportDeclaration(node: any): boolean; +export declare function getParentExportDeclaration(path: any): any; +export declare function isTrailingCommaEnabled(options: any, context: any): boolean; diff --git a/tools/ui/node_modules/recast/lib/util.js b/tools/ui/node_modules/recast/lib/util.js new file mode 100644 index 0000000000000000000000000000000000000000..78ea9af46988c9e164ace7adcfcc16119f1c11d7 --- /dev/null +++ b/tools/ui/node_modules/recast/lib/util.js @@ -0,0 +1,331 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isTrailingCommaEnabled = exports.getParentExportDeclaration = exports.isExportDeclaration = exports.fixFaultyLocations = exports.getTrueLoc = exports.composeSourceMaps = exports.copyPos = exports.comparePos = exports.getUnionOfKeys = exports.getOption = exports.isBrowser = exports.getLineTerminator = void 0; +var tslib_1 = require("tslib"); +var tiny_invariant_1 = tslib_1.__importDefault(require("tiny-invariant")); +var types = tslib_1.__importStar(require("ast-types")); +var n = types.namedTypes; +var source_map_1 = tslib_1.__importDefault(require("source-map")); +var SourceMapConsumer = source_map_1.default.SourceMapConsumer; +var SourceMapGenerator = source_map_1.default.SourceMapGenerator; +var hasOwn = Object.prototype.hasOwnProperty; +function getLineTerminator() { + return isBrowser() ? "\n" : require("os").EOL || "\n"; +} +exports.getLineTerminator = getLineTerminator; +function isBrowser() { + return (typeof window !== "undefined" && typeof window.document !== "undefined"); +} +exports.isBrowser = isBrowser; +function getOption(options, key, defaultValue) { + if (options && hasOwn.call(options, key)) { + return options[key]; + } + return defaultValue; +} +exports.getOption = getOption; +function getUnionOfKeys() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var result = {}; + var argc = args.length; + for (var i = 0; i < argc; ++i) { + var keys = Object.keys(args[i]); + var keyCount = keys.length; + for (var j = 0; j < keyCount; ++j) { + result[keys[j]] = true; + } + } + return result; +} +exports.getUnionOfKeys = getUnionOfKeys; +function comparePos(pos1, pos2) { + return pos1.line - pos2.line || pos1.column - pos2.column; +} +exports.comparePos = comparePos; +function copyPos(pos) { + return { + line: pos.line, + column: pos.column, + }; +} +exports.copyPos = copyPos; +function composeSourceMaps(formerMap, latterMap) { + if (formerMap) { + if (!latterMap) { + return formerMap; + } + } + else { + return latterMap || null; + } + var smcFormer = new SourceMapConsumer(formerMap); + var smcLatter = new SourceMapConsumer(latterMap); + var smg = new SourceMapGenerator({ + file: latterMap.file, + sourceRoot: latterMap.sourceRoot, + }); + var sourcesToContents = {}; + smcLatter.eachMapping(function (mapping) { + var origPos = smcFormer.originalPositionFor({ + line: mapping.originalLine, + column: mapping.originalColumn, + }); + var sourceName = origPos.source; + if (sourceName === null) { + return; + } + smg.addMapping({ + source: sourceName, + original: copyPos(origPos), + generated: { + line: mapping.generatedLine, + column: mapping.generatedColumn, + }, + name: mapping.name, + }); + var sourceContent = smcFormer.sourceContentFor(sourceName); + if (sourceContent && !hasOwn.call(sourcesToContents, sourceName)) { + sourcesToContents[sourceName] = sourceContent; + smg.setSourceContent(sourceName, sourceContent); + } + }); + return smg.toJSON(); +} +exports.composeSourceMaps = composeSourceMaps; +function getTrueLoc(node, lines) { + // It's possible that node is newly-created (not parsed by Esprima), + // in which case it probably won't have a .loc property (or an + // .original property for that matter). That's fine; we'll just + // pretty-print it as usual. + if (!node.loc) { + return null; + } + var result = { + start: node.loc.start, + end: node.loc.end, + }; + function include(node) { + expandLoc(result, node.loc); + } + // If the node is an export declaration and its .declaration has any + // decorators, their locations might contribute to the true start/end + // positions of the export declaration node. + if (node.declaration && + node.declaration.decorators && + isExportDeclaration(node)) { + node.declaration.decorators.forEach(include); + } + if (comparePos(result.start, result.end) < 0) { + // Trim leading whitespace. + result.start = copyPos(result.start); + lines.skipSpaces(result.start, false, true); + if (comparePos(result.start, result.end) < 0) { + // Trim trailing whitespace, if the end location is not already the + // same as the start location. + result.end = copyPos(result.end); + lines.skipSpaces(result.end, true, true); + } + } + // If the node has any comments, their locations might contribute to + // the true start/end positions of the node. + if (node.comments) { + node.comments.forEach(include); + } + return result; +} +exports.getTrueLoc = getTrueLoc; +function expandLoc(parentLoc, childLoc) { + if (parentLoc && childLoc) { + if (comparePos(childLoc.start, parentLoc.start) < 0) { + parentLoc.start = childLoc.start; + } + if (comparePos(parentLoc.end, childLoc.end) < 0) { + parentLoc.end = childLoc.end; + } + } +} +function fixFaultyLocations(node, lines) { + var loc = node.loc; + if (loc) { + if (loc.start.line < 1) { + loc.start.line = 1; + } + if (loc.end.line < 1) { + loc.end.line = 1; + } + } + if (node.type === "File") { + // Babylon returns File nodes whose .loc.{start,end} do not include + // leading or trailing whitespace. + loc.start = lines.firstPos(); + loc.end = lines.lastPos(); + } + fixForLoopHead(node, lines); + fixTemplateLiteral(node, lines); + if (loc && node.decorators) { + // Expand the .loc of the node responsible for printing the decorators + // (here, the decorated node) so that it includes node.decorators. + node.decorators.forEach(function (decorator) { + expandLoc(loc, decorator.loc); + }); + } + else if (node.declaration && isExportDeclaration(node)) { + // Nullify .loc information for the child declaration so that we never + // try to reprint it without also reprinting the export declaration. + node.declaration.loc = null; + // Expand the .loc of the node responsible for printing the decorators + // (here, the export declaration) so that it includes node.decorators. + var decorators = node.declaration.decorators; + if (decorators) { + decorators.forEach(function (decorator) { + expandLoc(loc, decorator.loc); + }); + } + } + else if ((n.MethodDefinition && n.MethodDefinition.check(node)) || + (n.Property.check(node) && (node.method || node.shorthand))) { + // If the node is a MethodDefinition or a .method or .shorthand + // Property, then the location information stored in + // node.value.loc is very likely untrustworthy (just the {body} + // part of a method, or nothing in the case of shorthand + // properties), so we null out that information to prevent + // accidental reuse of bogus source code during reprinting. + node.value.loc = null; + if (n.FunctionExpression.check(node.value)) { + // FunctionExpression method values should be anonymous, + // because their .id fields are ignored anyway. + node.value.id = null; + } + } + else if (node.type === "ObjectTypeProperty") { + var loc_1 = node.loc; + var end = loc_1 && loc_1.end; + if (end) { + end = copyPos(end); + if (lines.prevPos(end) && lines.charAt(end) === ",") { + // Some parsers accidentally include trailing commas in the + // .loc.end information for ObjectTypeProperty nodes. + if ((end = lines.skipSpaces(end, true, true))) { + loc_1.end = end; + } + } + } + } +} +exports.fixFaultyLocations = fixFaultyLocations; +function fixForLoopHead(node, lines) { + if (node.type !== "ForStatement") { + return; + } + function fix(child) { + var loc = child && child.loc; + var start = loc && loc.start; + var end = loc && copyPos(loc.end); + while (start && end && comparePos(start, end) < 0) { + lines.prevPos(end); + if (lines.charAt(end) === ";") { + // Update child.loc.end to *exclude* the ';' character. + loc.end.line = end.line; + loc.end.column = end.column; + } + else { + break; + } + } + } + fix(node.init); + fix(node.test); + fix(node.update); +} +function fixTemplateLiteral(node, lines) { + if (node.type !== "TemplateLiteral") { + return; + } + if (node.quasis.length === 0) { + // If there are no quasi elements, then there is nothing to fix. + return; + } + // node.loc is not present when using export default with a template literal + if (node.loc) { + // First we need to exclude the opening ` from the .loc of the first + // quasi element, in case the parser accidentally decided to include it. + var afterLeftBackTickPos = copyPos(node.loc.start); + (0, tiny_invariant_1.default)(lines.charAt(afterLeftBackTickPos) === "`"); + (0, tiny_invariant_1.default)(lines.nextPos(afterLeftBackTickPos)); + var firstQuasi = node.quasis[0]; + if (comparePos(firstQuasi.loc.start, afterLeftBackTickPos) < 0) { + firstQuasi.loc.start = afterLeftBackTickPos; + } + // Next we need to exclude the closing ` from the .loc of the last quasi + // element, in case the parser accidentally decided to include it. + var rightBackTickPos = copyPos(node.loc.end); + (0, tiny_invariant_1.default)(lines.prevPos(rightBackTickPos)); + (0, tiny_invariant_1.default)(lines.charAt(rightBackTickPos) === "`"); + var lastQuasi = node.quasis[node.quasis.length - 1]; + if (comparePos(rightBackTickPos, lastQuasi.loc.end) < 0) { + lastQuasi.loc.end = rightBackTickPos; + } + } + // Now we need to exclude ${ and } characters from the .loc's of all + // quasi elements, since some parsers accidentally include them. + node.expressions.forEach(function (expr, i) { + // Rewind from expr.loc.start over any whitespace and the ${ that + // precedes the expression. The position of the $ should be the same + // as the .loc.end of the preceding quasi element, but some parsers + // accidentally include the ${ in the .loc of the quasi element. + var dollarCurlyPos = lines.skipSpaces(expr.loc.start, true, false); + if (lines.prevPos(dollarCurlyPos) && + lines.charAt(dollarCurlyPos) === "{" && + lines.prevPos(dollarCurlyPos) && + lines.charAt(dollarCurlyPos) === "$") { + var quasiBefore = node.quasis[i]; + if (comparePos(dollarCurlyPos, quasiBefore.loc.end) < 0) { + quasiBefore.loc.end = dollarCurlyPos; + } + } + // Likewise, some parsers accidentally include the } that follows + // the expression in the .loc of the following quasi element. + var rightCurlyPos = lines.skipSpaces(expr.loc.end, false, false); + if (lines.charAt(rightCurlyPos) === "}") { + (0, tiny_invariant_1.default)(lines.nextPos(rightCurlyPos)); + // Now rightCurlyPos is technically the position just after the }. + var quasiAfter = node.quasis[i + 1]; + if (comparePos(quasiAfter.loc.start, rightCurlyPos) < 0) { + quasiAfter.loc.start = rightCurlyPos; + } + } + }); +} +function isExportDeclaration(node) { + if (node) + switch (node.type) { + case "ExportDeclaration": + case "ExportDefaultDeclaration": + case "ExportDefaultSpecifier": + case "DeclareExportDeclaration": + case "ExportNamedDeclaration": + case "ExportAllDeclaration": + return true; + } + return false; +} +exports.isExportDeclaration = isExportDeclaration; +function getParentExportDeclaration(path) { + var parentNode = path.getParentNode(); + if (path.getName() === "declaration" && isExportDeclaration(parentNode)) { + return parentNode; + } + return null; +} +exports.getParentExportDeclaration = getParentExportDeclaration; +function isTrailingCommaEnabled(options, context) { + var trailingComma = options.trailingComma; + if (typeof trailingComma === "object") { + return !!trailingComma[context]; + } + return !!trailingComma; +} +exports.isTrailingCommaEnabled = isTrailingCommaEnabled; diff --git a/tools/ui/node_modules/recast/main.d.ts b/tools/ui/node_modules/recast/main.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ae89c3b22473a643697bccc13ffaeed3340e4017 --- /dev/null +++ b/tools/ui/node_modules/recast/main.d.ts @@ -0,0 +1,50 @@ +import * as types from "ast-types"; +import { parse } from "./lib/parser"; +import { Options } from "./lib/options"; +export { +/** + * Parse a string of code into an augmented syntax tree suitable for + * arbitrary modification and reprinting. + */ +parse, +/** + * Convenient shorthand for the ast-types package. + */ +types, }; +/** + * Traverse and potentially modify an abstract syntax tree using a + * convenient visitor syntax: + * + * recast.visit(ast, { + * names: [], + * visitIdentifier: function(path) { + * var node = path.value; + * this.visitor.names.push(node.name); + * this.traverse(path); + * } + * }); + */ +export { visit } from "ast-types"; +/** + * Options shared between parsing and printing. + */ +export { Options } from "./lib/options"; +/** + * Reprint a modified syntax tree using as much of the original source + * code as possible. + */ +export declare function print(node: types.ASTNode, options?: Options): import("./lib/printer").PrintResultType; +/** + * Print without attempting to reuse any original source code. + */ +export declare function prettyPrint(node: types.ASTNode, options?: Options): import("./lib/printer").PrintResultType; +/** + * Convenient command-line interface (see e.g. example/add-braces). + */ +export declare function run(transformer: Transformer, options?: RunOptions): void; +export interface Transformer { + (ast: types.ASTNode, callback: (ast: types.ASTNode) => void): void; +} +export interface RunOptions extends Options { + writeback?(code: string): void; +} diff --git a/tools/ui/node_modules/recast/main.js b/tools/ui/node_modules/recast/main.js new file mode 100644 index 0000000000000000000000000000000000000000..4ef3aff5aac9e1b6910e67a1ab99b38d8fb3f78f --- /dev/null +++ b/tools/ui/node_modules/recast/main.js @@ -0,0 +1,65 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.run = exports.prettyPrint = exports.print = exports.visit = exports.types = exports.parse = void 0; +var tslib_1 = require("tslib"); +var fs_1 = tslib_1.__importDefault(require("fs")); +var types = tslib_1.__importStar(require("ast-types")); +exports.types = types; +var parser_1 = require("./lib/parser"); +Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parser_1.parse; } }); +var printer_1 = require("./lib/printer"); +/** + * Traverse and potentially modify an abstract syntax tree using a + * convenient visitor syntax: + * + * recast.visit(ast, { + * names: [], + * visitIdentifier: function(path) { + * var node = path.value; + * this.visitor.names.push(node.name); + * this.traverse(path); + * } + * }); + */ +var ast_types_1 = require("ast-types"); +Object.defineProperty(exports, "visit", { enumerable: true, get: function () { return ast_types_1.visit; } }); +/** + * Reprint a modified syntax tree using as much of the original source + * code as possible. + */ +function print(node, options) { + return new printer_1.Printer(options).print(node); +} +exports.print = print; +/** + * Print without attempting to reuse any original source code. + */ +function prettyPrint(node, options) { + return new printer_1.Printer(options).printGenerically(node); +} +exports.prettyPrint = prettyPrint; +/** + * Convenient command-line interface (see e.g. example/add-braces). + */ +function run(transformer, options) { + return runFile(process.argv[2], transformer, options); +} +exports.run = run; +function runFile(path, transformer, options) { + fs_1.default.readFile(path, "utf-8", function (err, code) { + if (err) { + console.error(err); + return; + } + runString(code, transformer, options); + }); +} +function defaultWriteback(output) { + process.stdout.write(output); +} +function runString(code, transformer, options) { + var writeback = (options && options.writeback) || defaultWriteback; + transformer((0, parser_1.parse)(code, options), function (node) { + writeback(print(node, options).code); + }); +} diff --git a/tools/ui/node_modules/recast/package.json b/tools/ui/node_modules/recast/package.json new file mode 100644 index 0000000000000000000000000000000000000000..8e94e341ba5d41e352d313d28461f01da29315b2 --- /dev/null +++ b/tools/ui/node_modules/recast/package.json @@ -0,0 +1,74 @@ +{ + "author": "Ben Newman ", + "name": "recast", + "version": "0.23.11", + "description": "JavaScript syntax tree transformer, nondestructive pretty-printer, and automatic source map generator", + "keywords": [ + "ast", + "rewriting", + "refactoring", + "codegen", + "syntax", + "transformation", + "parsing", + "pretty-printing" + ], + "homepage": "http://github.com/benjamn/recast", + "repository": { + "type": "git", + "url": "git://github.com/benjamn/recast.git" + }, + "license": "MIT", + "main": "main.js", + "types": "main.d.ts", + "scripts": { + "mocha": "test/run.sh", + "debug": "test/run.sh --inspect-brk", + "test": "npm run lint && npm run build && npm run mocha", + "build": "npm run clean && tsc", + "lint": "eslint --ext .ts .", + "format": "prettier --write .", + "format:check": "prettier --check .", + "clean": "tsc --build --clean", + "prepare": "npm run build", + "postpack": "npm run clean" + }, + "lint-staged": { + "*.ts": [ + "eslint", + "prettier -c" + ] + }, + "browser": { + "fs": false + }, + "dependencies": { + "ast-types": "^0.16.1", + "esprima": "~4.0.0", + "source-map": "~0.6.1", + "tiny-invariant": "^1.3.3", + "tslib": "^2.0.1" + }, + "devDependencies": { + "@babel/core": "7.20.5", + "@babel/parser": "7.20.5", + "@babel/preset-env": "7.20.2", + "@types/esprima": "4.0.3", + "@types/glob": "8.0.0", + "@types/mocha": "10.0.1", + "@types/node": "18.11.15", + "@typescript-eslint/parser": "^5.47.1", + "eslint": "^8.40.0", + "esprima-fb": "15001.1001.0-dev-harmony-fb", + "flow-parser": "0.195.0", + "glob": "8.0.3", + "lint-staged": "^13.2.2", + "mocha": "^10.2.0", + "prettier": "^2.6.2", + "reify": "0.20.12", + "typescript": "^4.9.4" + }, + "engines": { + "node": ">= 4" + } +} diff --git a/tools/ui/node_modules/recast/parsers/_babel_options.d.ts b/tools/ui/node_modules/recast/parsers/_babel_options.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..76c9cf8fea8c708da0405bc188e3679cdd974c98 --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/_babel_options.d.ts @@ -0,0 +1,8 @@ +import { ParserOptions, ParserPlugin } from "@babel/parser"; +export type Overrides = Partial<{ + sourceType: ParserOptions["sourceType"]; + strictMode: ParserOptions["strictMode"]; +}>; +export default function getBabelOptions(options?: Overrides): ParserOptions & { + plugins: ParserPlugin[]; +}; diff --git a/tools/ui/node_modules/recast/parsers/_babel_options.js b/tools/ui/node_modules/recast/parsers/_babel_options.js new file mode 100644 index 0000000000000000000000000000000000000000..d8fa77b7b0c6cfe6f9e27f570c8f7bd2c1e3141d --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/_babel_options.js @@ -0,0 +1,57 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util_1 = require("../lib/util"); +function getBabelOptions(options) { + // The goal here is to tolerate as much syntax as possible, since Recast + // is not in the business of forbidding anything. If you want your + // parser to be more restrictive for some reason, you can always pass + // your own parser object to recast.parse. + return { + sourceType: (0, util_1.getOption)(options, "sourceType", "module"), + strictMode: (0, util_1.getOption)(options, "strictMode", false), + allowImportExportEverywhere: true, + allowReturnOutsideFunction: true, + startLine: 1, + tokens: true, + plugins: [ + "asyncGenerators", + "bigInt", + "classPrivateMethods", + "classPrivateProperties", + "classProperties", + "classStaticBlock", + "decimal", + "decorators-legacy", + "doExpressions", + "dynamicImport", + "exportDefaultFrom", + "exportExtensions", + "exportNamespaceFrom", + "functionBind", + "functionSent", + "importAssertions", + "importMeta", + "nullishCoalescingOperator", + "numericSeparator", + "objectRestSpread", + "optionalCatchBinding", + "optionalChaining", + [ + "pipelineOperator", + { + proposal: "minimal", + }, + ], + [ + "recordAndTuple", + { + syntaxType: "hash", + }, + ], + "throwExpressions", + "topLevelAwait", + "v8intrinsic", + ], + }; +} +exports.default = getBabelOptions; diff --git a/tools/ui/node_modules/recast/parsers/acorn.d.ts b/tools/ui/node_modules/recast/parsers/acorn.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4ad665365d1453434127a6ba941f4dc3d3d799c2 --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/acorn.d.ts @@ -0,0 +1 @@ +export declare function parse(source: string, options?: any): any; diff --git a/tools/ui/node_modules/recast/parsers/acorn.js b/tools/ui/node_modules/recast/parsers/acorn.js new file mode 100644 index 0000000000000000000000000000000000000000..4dfe8b6eb6271defe3b8b077009e73aae591e18d --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/acorn.js @@ -0,0 +1,33 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parse = void 0; +// This module is suitable for passing as options.parser when calling +// recast.parse to process JavaScript code with Acorn: +// +// const ast = recast.parse(source, { +// parser: require("recast/parsers/acorn") +// }); +// +var util_1 = require("../lib/util"); +function parse(source, options) { + var comments = []; + var tokens = []; + var ast = require("acorn").parse(source, { + allowHashBang: true, + allowImportExportEverywhere: true, + allowReturnOutsideFunction: true, + ecmaVersion: (0, util_1.getOption)(options, "ecmaVersion", 8), + sourceType: (0, util_1.getOption)(options, "sourceType", "module"), + locations: true, + onComment: comments, + onToken: tokens, + }); + if (!ast.comments) { + ast.comments = comments; + } + if (!ast.tokens) { + ast.tokens = tokens; + } + return ast; +} +exports.parse = parse; diff --git a/tools/ui/node_modules/recast/parsers/babel-ts.d.ts b/tools/ui/node_modules/recast/parsers/babel-ts.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9da143ee899500b02b5b841ee0402bfa0958a8be --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/babel-ts.d.ts @@ -0,0 +1,4 @@ +import { parser } from "./babel"; +import { Overrides } from "./_babel_options"; +export { parser }; +export declare function parse(source: string, options?: Overrides): import("@babel/parser").ParseResult; diff --git a/tools/ui/node_modules/recast/parsers/babel-ts.js b/tools/ui/node_modules/recast/parsers/babel-ts.js new file mode 100644 index 0000000000000000000000000000000000000000..9fdf6f3f75a030ff695d8251b19d7ce28c42f68e --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/babel-ts.js @@ -0,0 +1,13 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parse = exports.parser = void 0; +var tslib_1 = require("tslib"); +var babel_1 = require("./babel"); +Object.defineProperty(exports, "parser", { enumerable: true, get: function () { return babel_1.parser; } }); +var _babel_options_1 = tslib_1.__importDefault(require("./_babel_options")); +function parse(source, options) { + var babelOptions = (0, _babel_options_1.default)(options); + babelOptions.plugins.push("jsx", "typescript"); + return babel_1.parser.parse(source, babelOptions); +} +exports.parse = parse; diff --git a/tools/ui/node_modules/recast/parsers/babel.d.ts b/tools/ui/node_modules/recast/parsers/babel.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..da9283f4f293044e0454b98b87336d7c1fe18a40 --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/babel.d.ts @@ -0,0 +1,8 @@ +import { parse as babelParse } from "@babel/parser"; +import { Overrides } from "./_babel_options"; +type BabelParser = { + parse: typeof babelParse; +}; +export declare const parser: BabelParser; +export declare function parse(source: string, options?: Overrides): import("@babel/parser").ParseResult; +export {}; diff --git a/tools/ui/node_modules/recast/parsers/babel.js b/tools/ui/node_modules/recast/parsers/babel.js new file mode 100644 index 0000000000000000000000000000000000000000..9865fc5d1216eaede68f102d4e7651dd0a0796eb --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/babel.js @@ -0,0 +1,33 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parse = exports.parser = void 0; +var tslib_1 = require("tslib"); +var _babel_options_1 = tslib_1.__importDefault(require("./_babel_options")); +// Prefer the new @babel/parser package, but fall back to babylon if +// that's what's available. +exports.parser = (function () { + try { + return require("@babel/parser"); + } + catch (_a) { + try { + return require("babylon"); + } + catch (_b) { + throw new Error("Install @babel/parser to use the `typescript`, `flow`, or `babel` parsers"); + } + } +})(); +// This module is suitable for passing as options.parser when calling +// recast.parse to process JavaScript code with Babel: +// +// const ast = recast.parse(source, { +// parser: require("recast/parsers/babel") +// }); +// +function parse(source, options) { + var babelOptions = (0, _babel_options_1.default)(options); + babelOptions.plugins.push("jsx", "flow", "decoratorAutoAccessors"); + return exports.parser.parse(source, babelOptions); +} +exports.parse = parse; diff --git a/tools/ui/node_modules/recast/parsers/babylon.d.ts b/tools/ui/node_modules/recast/parsers/babylon.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..60fce87ff55bcacbbacf7e997c018d0694636a76 --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/babylon.d.ts @@ -0,0 +1 @@ +export * from "./babel"; diff --git a/tools/ui/node_modules/recast/parsers/babylon.js b/tools/ui/node_modules/recast/parsers/babylon.js new file mode 100644 index 0000000000000000000000000000000000000000..a3ddb866f531f3e4e9e41832d82cb4ddf8b97eac --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/babylon.js @@ -0,0 +1,4 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var tslib_1 = require("tslib"); +tslib_1.__exportStar(require("./babel"), exports); diff --git a/tools/ui/node_modules/recast/parsers/esprima.d.ts b/tools/ui/node_modules/recast/parsers/esprima.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4ad665365d1453434127a6ba941f4dc3d3d799c2 --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/esprima.d.ts @@ -0,0 +1 @@ +export declare function parse(source: string, options?: any): any; diff --git a/tools/ui/node_modules/recast/parsers/esprima.js b/tools/ui/node_modules/recast/parsers/esprima.js new file mode 100644 index 0000000000000000000000000000000000000000..2c81e77b4e41df38f63dc1082da41f795ec4c821 --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/esprima.js @@ -0,0 +1,30 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parse = void 0; +// This module is suitable for passing as options.parser when calling +// recast.parse to process ECMAScript code with Esprima: +// +// const ast = recast.parse(source, { +// parser: require("recast/parsers/esprima") +// }); +// +var util_1 = require("../lib/util"); +function parse(source, options) { + var comments = []; + var ast = require("esprima").parse(source, { + loc: true, + locations: true, + comment: true, + onComment: comments, + range: (0, util_1.getOption)(options, "range", false), + tolerant: (0, util_1.getOption)(options, "tolerant", true), + tokens: true, + jsx: (0, util_1.getOption)(options, "jsx", false), + sourceType: (0, util_1.getOption)(options, "sourceType", "module"), + }); + if (!Array.isArray(ast.comments)) { + ast.comments = comments; + } + return ast; +} +exports.parse = parse; diff --git a/tools/ui/node_modules/recast/parsers/flow.d.ts b/tools/ui/node_modules/recast/parsers/flow.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..65e14fef592bd08b9e009a3e9b7d458eb31458a3 --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/flow.d.ts @@ -0,0 +1,2 @@ +import { Overrides } from "./_babel_options"; +export declare function parse(source: string, options?: Overrides): import("@babel/parser").ParseResult; diff --git a/tools/ui/node_modules/recast/parsers/flow.js b/tools/ui/node_modules/recast/parsers/flow.js new file mode 100644 index 0000000000000000000000000000000000000000..780fa66e69a5fdd26e74e917467fdb9b80ae6524 --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/flow.js @@ -0,0 +1,19 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parse = void 0; +var tslib_1 = require("tslib"); +var babel_1 = require("./babel"); +var _babel_options_1 = tslib_1.__importDefault(require("./_babel_options")); +// This module is suitable for passing as options.parser when calling +// recast.parse to process Flow code: +// +// const ast = recast.parse(source, { +// parser: require("recast/parsers/flow") +// }); +// +function parse(source, options) { + var babelOptions = (0, _babel_options_1.default)(options); + babelOptions.plugins.push("jsx", "flow"); + return babel_1.parser.parse(source, babelOptions); +} +exports.parse = parse; diff --git a/tools/ui/node_modules/recast/parsers/typescript.d.ts b/tools/ui/node_modules/recast/parsers/typescript.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..65e14fef592bd08b9e009a3e9b7d458eb31458a3 --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/typescript.d.ts @@ -0,0 +1,2 @@ +import { Overrides } from "./_babel_options"; +export declare function parse(source: string, options?: Overrides): import("@babel/parser").ParseResult; diff --git a/tools/ui/node_modules/recast/parsers/typescript.js b/tools/ui/node_modules/recast/parsers/typescript.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9e2a2579428540eeb673ce394174194e90965f --- /dev/null +++ b/tools/ui/node_modules/recast/parsers/typescript.js @@ -0,0 +1,19 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parse = void 0; +var tslib_1 = require("tslib"); +var babel_1 = require("./babel"); +var _babel_options_1 = tslib_1.__importDefault(require("./_babel_options")); +// This module is suitable for passing as options.parser when calling +// recast.parse to process TypeScript code: +// +// const ast = recast.parse(source, { +// parser: require("recast/parsers/typescript") +// }); +// +function parse(source, options) { + var babelOptions = (0, _babel_options_1.default)(options); + babelOptions.plugins.push("typescript"); + return babel_1.parser.parse(source, babelOptions); +} +exports.parse = parse; diff --git a/tools/ui/node_modules/recast/tsconfig.json b/tools/ui/node_modules/recast/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..b148a05c224e19a09d24d0dc362a7c898d3c52ad --- /dev/null +++ b/tools/ui/node_modules/recast/tsconfig.json @@ -0,0 +1,18 @@ +{ + "compilerOptions": { + "target": "es5", + "lib": ["es2015"], + "module": "commonjs", + "declaration": true, + "rootDir": ".", + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noImplicitReturns": true, + "moduleResolution": "node", + "esModuleInterop": true, + "importHelpers": true, + "stripInternal": true + }, + "exclude": ["node_modules", "test/data"] +} diff --git a/tools/ui/node_modules/redent/index.d.ts b/tools/ui/node_modules/redent/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..67b94c768d59af0297cab0874bc7f79b56bc8921 --- /dev/null +++ b/tools/ui/node_modules/redent/index.d.ts @@ -0,0 +1,27 @@ +import {Options as IndentStringOptions} from 'indent-string'; + +declare namespace redent { + type Options = IndentStringOptions; +} + +/** +[Strip redundant indentation](https://github.com/sindresorhus/strip-indent) and [indent the string](https://github.com/sindresorhus/indent-string). + +@param string - The string to normalize indentation. +@param count - How many times you want `options.indent` repeated. Default: `0`. + +@example +``` +import redent = require('redent'); + +redent('\n foo\n bar\n', 1); +//=> '\n foo\n bar\n' +``` +*/ +declare function redent( + string: string, + count?: number, + options?: redent.Options +): string; + +export = redent; diff --git a/tools/ui/node_modules/redent/index.js b/tools/ui/node_modules/redent/index.js new file mode 100644 index 0000000000000000000000000000000000000000..9457849d8f946bb2d2f0f19ba2d4968777defee1 --- /dev/null +++ b/tools/ui/node_modules/redent/index.js @@ -0,0 +1,5 @@ +'use strict'; +const stripIndent = require('strip-indent'); +const indentString = require('indent-string'); + +module.exports = (string, count = 0, options) => indentString(stripIndent(string), count, options); diff --git a/tools/ui/node_modules/redent/license b/tools/ui/node_modules/redent/license new file mode 100644 index 0000000000000000000000000000000000000000..e7af2f77107d73046421ef56c4684cbfdd3c1e89 --- /dev/null +++ b/tools/ui/node_modules/redent/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/redent/package.json b/tools/ui/node_modules/redent/package.json new file mode 100644 index 0000000000000000000000000000000000000000..89b5021cacbb3a737965690772c38cd7048a98bf --- /dev/null +++ b/tools/ui/node_modules/redent/package.json @@ -0,0 +1,44 @@ +{ + "name": "redent", + "version": "3.0.0", + "description": "Strip redundant indentation and indent the string", + "license": "MIT", + "repository": "sindresorhus/redent", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "sindresorhus.com" + }, + "engines": { + "node": ">=8" + }, + "scripts": { + "test": "xo && ava && tsd" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "string", + "strip", + "trim", + "indent", + "indentation", + "add", + "reindent", + "normalize", + "remove", + "whitespace", + "space" + ], + "dependencies": { + "indent-string": "^4.0.0", + "strip-indent": "^3.0.0" + }, + "devDependencies": { + "ava": "^1.4.1", + "tsd": "^0.7.2", + "xo": "^0.24.0" + } +} diff --git a/tools/ui/node_modules/redent/readme.md b/tools/ui/node_modules/redent/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..8a186c2ad48894d86bb7acb9c0ebf50313cf1db1 --- /dev/null +++ b/tools/ui/node_modules/redent/readme.md @@ -0,0 +1,61 @@ +# redent [![Build Status](https://travis-ci.org/sindresorhus/redent.svg?branch=master)](https://travis-ci.org/sindresorhus/redent) + +> [Strip redundant indentation](https://github.com/sindresorhus/strip-indent) and [indent the string](https://github.com/sindresorhus/indent-string) + + +## Install + +``` +$ npm install redent +``` + + +## Usage + +```js +const redent = require('redent'); + +redent('\n foo\n bar\n', 1); +//=> '\n foo\n bar\n' +``` + + +## API + +### redent(string, [count], [options]) + +#### string + +Type: `string` + +The string to normalize indentation. + +#### count + +Type: `number`
+Default: `0` + +How many times you want `options.indent` repeated. + +#### options + +Type: `object` + +##### indent + +Type: `string`
+Default: `' '` + +The string to use for the indent. + +##### includeEmptyLines + +Type: `boolean`
+Default: `false` + +Also indent empty lines. + + +## License + +MIT © [Sindre Sorhus](https://sindresorhus.com) diff --git a/tools/ui/node_modules/reflect.getprototypeof/.eslintrc b/tools/ui/node_modules/reflect.getprototypeof/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..48be5f33a01ecc13b7dd2188a0b73e9f0178276a --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/.eslintrc @@ -0,0 +1,17 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "id-length": 0, + "max-statements": [2, 25], + "new-cap": [2, { + "capIsNewExceptions": [ + "GetIntrinsic", + "IsCallable", + "Type", + ], + }], + }, +} diff --git a/tools/ui/node_modules/reflect.getprototypeof/.nycrc b/tools/ui/node_modules/reflect.getprototypeof/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..bdd626ce91477abbdd489b79988baebadbd3c897 --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/reflect.getprototypeof/CHANGELOG.md b/tools/ui/node_modules/reflect.getprototypeof/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..02a4353bc4132f93e258b92ad4bbccf08f03756b --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/CHANGELOG.md @@ -0,0 +1,115 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.0.10](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.9...v1.0.10) - 2025-01-02 + +### Commits + +- [Refactor] use `es-object-atoms` and `get-proto` directly [`2c55da0`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/2c55da02fb56d9ce7a19e505f487dfb088256d24) +- [Refactor] use `isObject` helper instead of `Type` [`e4c24a4`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/e4c24a4cc1b9928da3eb1f0a032703235d32855e) +- [Deps] update `es-abstract`, `get-intrinsic` [`54005fb`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/54005fb9df56fb399e0c526600cb7799d23ef64f) +- [Deps] update `es-abstract` [`e71b3b7`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/e71b3b75847d4af71e42ff049bd2b4d55f0324fc) + +## [v1.0.9](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.8...v1.0.9) - 2024-12-18 + +### Commits + +- [Fix] avoid a crash with node `--disable-proto=throw` flag [`73f449d`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/73f449dff08fe574a4cd937d7265aceb1774de05) +- [Deps] update `dunder-proto`, `es-abstract`, `get-intrinsic`, `which-builtin-type` [`80c8227`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/80c8227aac6cef446ac8460f8bbdd9a83bd1d131) + +## [v1.0.8](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.7...v1.0.8) - 2024-12-06 + +### Commits + +- [Refactor] share the getDunderProto helper [`f4be71b`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/f4be71b2941f217311210a00d84d8338b4880e2a) +- [Refactor] extract helper to `dunder-proto` [`51dcd35`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/51dcd3547ef9808c9fee7aa4a638d3d5d93db70c) +- [Deps] update `call-bind` [`c06e8d3`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/c06e8d3c1c9b567ca5bd6bb8542ae2e342f276ff) +- [Deps] update `gopd` [`c951a70`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/c951a709d5483fecc4041287a676d881295d1940) +- [Deps] update `gopd` [`8bd7b85`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/8bd7b8524aacc0574c979e3fe4f82adc51b03f3f) +- [Deps] update `which-builtin-type` [`f46f624`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/f46f62423c1c452063f73d34a363c127410742b2) + +## [v1.0.7](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.6...v1.0.7) - 2024-11-23 + +### Commits + +- [Fix] cache `Object.prototype[__proto__]` getter [`68acea1`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/68acea171951197f83bb107af9e186ce68a5a78f) +- [Tests] remove unused test file [`055596a`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/055596aa2e050e08d35f8f19aa642e9b61a54f7f) +- [actions] split out node 10-20, and 20+ [`99a57c2`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/99a57c2551d11de70ea90b934e02b04ff3cec6c0) +- [Dev Deps] update `@es-shims/api`, `@ljharb/eslint-config`, `auto-changelog`, `tape` [`fe4bb92`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/fe4bb92a4d629e629f42f76567d837f8f17643a4) +- [Deps] update `es-abstract`, `globalthis`, `which-builtin-type` [`867aeb3`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/867aeb3c434ee03fd819da09d23a32a2c71290dc) +- [Tests] replace `aud` with `npm audit` [`5129c11`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/5129c112e18e3475afe42a836ac5d4d7ddfcfc18) +- [Deps] remove unused dep; add missing dev dep [`23cf537`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/23cf537aeac98bf27a8d39e24048e1c9fa4df7a7) +- [Dev Deps] add missing peer dep [`18862fa`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/18862fa57d2aa86825998db935ac6ffe23dec113) + +## [v1.0.6](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.5...v1.0.6) - 2024-03-16 + +### Commits + +- [meta] remove useless ESM [`cc16ab1`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/cc16ab1f3b050c9465b41fbbf79e284e8e9084ff) +- [Deps] update `call-bind`, `es-abstract`, `es-errors`, `get-intrinsic` [`ece7445`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/ece7445f03d148c67f5fc91ea455a05731b54cea) +- [Dev Deps] update `tape` [`a894b62`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/a894b624c16247cbb76a00e76a39e3d44ac5bccf) + +## [v1.0.5](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.4...v1.0.5) - 2024-02-04 + +### Commits + +- [Refactor] use `es-errors` where possible, so things that only need those do not need `get-intrinsic` [`08735cb`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/08735cba1dfeabae4e362b61e6de36843a472d22) +- [Deps] update `call-bind`, `define-properties`, `es-abstract`, `get-intrinsic` [`b5700ec`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/b5700eca8af88bbc693b304567d6124d13c03827) +- [Dev Deps] update `aud`, `npmignore`, `tape` [`f80fcbb`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/f80fcbb140661c07aa2a94547ffae0a5a8f937ac) + +## [v1.0.4](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.3...v1.0.4) - 2023-08-30 + +### Commits + +- [Deps] update `define-properties`, `es-abstract`, `get-intrinsic` [`325044f`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/325044f152c87f18344ba558b5967e69298a5dd2) +- [Dev Deps] update `@es-shims/api`, `@ljharb/eslint-config`, `aud`, `tape` [`56b9555`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/56b9555a536207493c4e2c17f1fee2390535a659) + +## [v1.0.3](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.2...v1.0.3) - 2022-11-07 + +### Commits + +- [actions] reuse common workflows [`0a76d97`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/0a76d972c13cd319504d3eecf8e7e00e39327c88) +- [meta] use `npmignore` to autogenerate an npmignore file [`c4861b4`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/c4861b45aeebddd1d998bdd44438b29e4bf974e8) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `@es-shims/api`, `safe-publish-latest`, `tape` [`e5352ab`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/e5352ab099f7104c085ffd2ee8fbfec69546fa2c) +- [actions] update codecov uploader [`dbcedf8`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/dbcedf83e967e17316fc98fb18011c603bb54823) +- [Deps] update `define-properties`, `es-abstract`, `globalthis`, `which-builtin-type` [`84fbfab`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/84fbfabe53774587be4748df303cec8acded7c0f) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `tape` [`75dc8a3`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/75dc8a337f11f11a947241c968bb7f5b843a1d17) +- [actions] update rebase action to use reusable workflow [`49463a7`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/49463a7a6d9aaa08c201ff4206efcade7a997175) +- [Dev Deps] update `@es-shims/api` [`adf75cb`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/adf75cb9dbda9052437a8e48e33da28dc52aa63c) + +## [v1.0.2](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.1...v1.0.2) - 2021-10-03 + +### Commits + +- [Deps] update `es-abstract` [`947bbb1`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/947bbb1bff0cc08ab80bb809a19771c6087e9fda) +- [actions] update workflows` [`af4708d`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/af4708d75212ee5781b549b1ff86f903fc659e3f) + +## [v1.0.1](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.0...v1.0.1) - 2021-09-08 + +### Commits + +- [actions] use `node/install` instead of `node/run`; use `codecov` action [`86f4aa3`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/86f4aa392c73220ecb561d644def5c3efab4f9f5) +- [Refactor] remove unnecessary ESM files [`162e4bf`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/162e4bfb58fb4eba6f2f26f11b0f46a8ea6587a7) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `@es-shims/api`, `aud`, `auto-changelog`, `tape` [`5515a8d`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/5515a8d17fc1978792db7e57a79f7f2fa60dc55e) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`db05b43`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/db05b43dff616acab04544ab04bd385d462b8572) +- [readme] add github actions/codecov badges [`d9ea295`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/d9ea295264f1d415b5083b3d4116b14a5a8ee7ff) +- [Deps] update `es-abstract`, `which-builtin-type` [`1753dee`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/1753deeaadbd66bb65e140e4bc81cee6652f07cd) +- [Dev Deps] update `eslint`, `tape` [`4bce2db`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/4bce2db34c4182edd0bf3610eaeb1ea42844ee15) +- [Deps] update `es-abstract`, `get-intrinsic` [`1dca685`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/1dca685d1e5305b6720882ac8f4d5038a8309431) +- [meta] use `prepublishOnly` script for npm 7+ [`1108273`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/1108273eba643ac8b135d177c21dd371ccb32901) +- [actions] update workflows [`8674d66`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/8674d662705675531d216bdba2b7e1e26be1b12b) +- [Deps] update `es-abstract` [`4e4fdcf`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/4e4fdcf854f3cd71d71aa80723664f5d2b814dad) + +## v1.0.0 - 2021-01-12 + +### Commits + +- es-shims initial commit [`ffd0b98`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/ffd0b980b47f0b2db6bc3373364e950f6fce33cb) +- Initial commit [`64c868f`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/64c868fa1bb3630f4ab823aaba98d0f28b3f8078) +- [meta] add Automatic Rebase and Require Allow Edits workflows [`6a006b4`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/6a006b4ddebfe68fd23b2870c83aadefecf80b04) +- [meta] Only apps should have lockfiles [`d1a29b5`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/d1a29b5b37d31129ecc1fecac1922d4c4935f9fa) +- [Deps] update `call-bind` [`bfcc1a0`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/bfcc1a0bd04fffe5fe53e791dd40f7988bbd5d03) diff --git a/tools/ui/node_modules/reflect.getprototypeof/LICENSE b/tools/ui/node_modules/reflect.getprototypeof/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..40680dc46440def7d07ef1702e0490a87cf3a125 --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 ECMAScript Shims + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/reflect.getprototypeof/README.md b/tools/ui/node_modules/reflect.getprototypeof/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f19646810973c25946c90cfed623ac96f74d7d5d --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/README.md @@ -0,0 +1,77 @@ +# reflect.getprototypeof [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +An ES2015 mostly-spec-compliant `Reflect.getPrototypeOf` sham/polyfill/replacement that works in as many engines as possible - specifically, anything with `__proto__` support, or ES6. Built-in types will also work correctly in older engines. + +This package implements the [es-shim API](https://github.com/es-shims/api) interface. It works in an ES3-supported environment and complies with the [spec](https://www.ecma-international.org/ecma-262/5.1/). + +## Example + +```js +var getPrototypeOf = require('reflect.getprototypeof'); +var assert = require('assert'); + +assert.throws(() => getPrototypeOf(true)); +assert.throws(() => getPrototypeOf(42)); +assert.throws(() => getPrototypeOf('')); +assert.equal(getPrototypeOf(/a/g), RegExp.prototype); +assert.equal(getPrototypeOf(new Date()), Date.prototype); +assert.equal(getPrototypeOf(function () {}), Function.prototype); +assert.equal(getPrototypeOf([]), Array.prototype); +assert.equal(getPrototypeOf({}), Object.prototype); +``` + +```js +var getPrototypeOf = require('reflect.getprototypeof'); +var assert = require('assert'); +/* when Reflect or Reflect.getPrototypeOf is not present */ +if (typeof Reflect === 'object') { delete Reflect.getPrototypeOf; } +delete globalThis.Reflect; +var shimmed = getPrototypeOf.shim(); +assert.equal(shimmed, getPrototypeOf.getPolyfill()); + +assert.throws(() => Reflect.getPrototypeOf(true)); +assert.throws(() => Reflect.getPrototypeOf(42)); +assert.throws(() => Reflect.getPrototypeOf('')); +assert.equal(Reflect.getPrototypeOf(/a/g), RegExp.prototype); +assert.equal(Reflect.getPrototypeOf(new Date()), Date.prototype); +assert.equal(Reflect.getPrototypeOf(function () {}), Function.prototype); +assert.equal(Reflect.getPrototypeOf([]), Array.prototype); +assert.equal(Reflect.getPrototypeOf({}), Object.prototype); +``` + +```js +var getPrototypeOf = require('reflect.getprototypeof'); +var assert = require('assert'); +/* when Reflect.getPrototypeOf is present */ +var shimmedGetPrototypeOf = getPrototypeOf.shim(); +assert.equal(shimmedGetPrototypeOf, Reflect.getPrototypeOf); +assert.equal(Reflect.getPrototypeOf([]), Array.prototype); +``` + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +[package-url]: https://npmjs.org/package/reflect.getprototypeof +[npm-version-svg]: https://versionbadg.es/es-shims/Reflect.getPrototypeOf.svg +[deps-svg]: https://david-dm.org/es-shims/Reflect.getPrototypeOf.svg +[deps-url]: https://david-dm.org/es-shims/Reflect.getPrototypeOf +[dev-deps-svg]: https://david-dm.org/es-shims/Reflect.getPrototypeOf/dev-status.svg +[dev-deps-url]: https://david-dm.org/es-shims/Reflect.getPrototypeOf#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/reflect.getprototypeof.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/reflect.getprototypeof.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/reflect.getprototypeof.svg +[downloads-url]: https://npm-stat.com/charts.html?package=reflect.getprototypeof +[codecov-image]: https://codecov.io/gh/es-shims/Reflect.getPrototypeOf/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/es-shims/Reflect.getPrototypeOf/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/es-shims/Reflect.getPrototypeOf +[actions-url]: https://github.com/es-shims/Reflect.getPrototypeOf/actions diff --git a/tools/ui/node_modules/reflect.getprototypeof/auto.js b/tools/ui/node_modules/reflect.getprototypeof/auto.js new file mode 100644 index 0000000000000000000000000000000000000000..8ebf606cb02ff3a8c6ef786afa37d21a19254f46 --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/auto.js @@ -0,0 +1,3 @@ +'use strict'; + +require('./shim')(); diff --git a/tools/ui/node_modules/reflect.getprototypeof/implementation.js b/tools/ui/node_modules/reflect.getprototypeof/implementation.js new file mode 100644 index 0000000000000000000000000000000000000000..a971fc0ed611b8b6f652e803ebf67ccaadac953c --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/implementation.js @@ -0,0 +1,40 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); +var IsCallable = require('es-abstract/2024/IsCallable'); +var isObject = require('es-abstract/helpers/isObject'); +var whichBuiltinType = require('which-builtin-type'); +var $TypeError = require('es-errors/type'); + +var gPO = require('get-proto'); +var $Object = require('es-object-atoms'); + +module.exports = function getPrototypeOf(O) { + if (!isObject(O)) { + throw new $TypeError('Reflect.getPrototypeOf called on non-object'); + } + + if (gPO) { + return gPO(O); + } + + var type = whichBuiltinType(O); + if (type) { + var intrinsic = GetIntrinsic('%' + type + '.prototype%', true); + if (intrinsic) { + return intrinsic; + } + } + if (IsCallable(O.constructor)) { + return O.constructor.prototype; + } + if (O instanceof Object) { + return $Object.prototype; + } + + /* + * Correctly return null for Objects created with `Object.create(null)` (shammed or native) or `{ __proto__: null}`. Also returns null for + * cross-realm objects on browsers that lack `__proto__` support (like IE <11), but that's the best we can do. + */ + return null; +}; diff --git a/tools/ui/node_modules/reflect.getprototypeof/index.js b/tools/ui/node_modules/reflect.getprototypeof/index.js new file mode 100644 index 0000000000000000000000000000000000000000..21d0a7b8783900a9650a23ed721c8b220831c132 --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/index.js @@ -0,0 +1,18 @@ +'use strict'; + +var callBind = require('call-bind'); +var define = require('define-properties'); + +var implementation = require('./implementation'); +var getPolyfill = require('./polyfill'); +var shim = require('./shim'); + +var bound = callBind(getPolyfill(), typeof Reflect === 'object' ? Reflect : Object); + +define(bound, { + getPolyfill: getPolyfill, + implementation: implementation, + shim: shim +}); + +module.exports = bound; diff --git a/tools/ui/node_modules/reflect.getprototypeof/package.json b/tools/ui/node_modules/reflect.getprototypeof/package.json new file mode 100644 index 0000000000000000000000000000000000000000..0e186a006c8009ce3fa9e328fb5173e2f8a86f54 --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/package.json @@ -0,0 +1,98 @@ +{ + "name": "reflect.getprototypeof", + "version": "1.0.10", + "description": "An ES2015 mostly-spec-compliant `Reflect.getPrototypeOf` sham/polyfill/replacement that works in as many engines as possible", + "main": "index.js", + "type": "commonjs", + "exports": { + ".": "./index.js", + "./auto": "./auto.js", + "./polyfill": "./polyfill.js", + "./implementation": "./implementation.js", + "./shim": "./shim.js", + "./package.json": "./package.json" + }, + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prepublishOnly": "safe-publish-latest", + "prelint": "evalmd README.md", + "lint": "eslint --ext=js,mjs .", + "postlint": "es-shim-api --bound", + "pretest": "npm run lint", + "tests-only": "nyc tape 'test/**/*.js'", + "test": "npm run tests-only", + "posttest": "npx npm@'>=10.2' audit --production", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/es-shims/Reflect.getPrototypeOf.git" + }, + "keywords": [ + "Reflect.getPrototypeOf", + "Object.getPrototypeOf", + "proto", + "__proto__", + "[[Prototype]]", + "getPrototypeOf", + "ES5", + "shim", + "polyfill", + "es-shim API", + "browser" + ], + "author": "Jordan Harband ", + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/es-shims/Reflect.getPrototypeOf/issues" + }, + "homepage": "https://github.com/es-shims/Reflect.getPrototypeOf", + "engines": { + "node": ">= 0.4" + }, + "dependencies": { + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.9", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "get-intrinsic": "^1.2.7", + "get-proto": "^1.0.1", + "which-builtin-type": "^1.2.1" + }, + "devDependencies": { + "@es-shims/api": "^2.5.1", + "@ljharb/eslint-config": "^21.1.1", + "auto-changelog": "^2.5.0", + "encoding": "^0.1.13", + "eslint": "=8.8.0", + "evalmd": "^0.0.19", + "functions-have-names": "^1.2.3", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + }, + "testling": { + "files": "test/implementation.js" + } +} diff --git a/tools/ui/node_modules/reflect.getprototypeof/polyfill.js b/tools/ui/node_modules/reflect.getprototypeof/polyfill.js new file mode 100644 index 0000000000000000000000000000000000000000..0c317e148b0503e37b241e2abdf812e4ed549bc3 --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/polyfill.js @@ -0,0 +1,14 @@ +'use strict'; + +var implementation = require('./implementation'); + +var getProto = require('get-proto'); + +module.exports = function getPolyfill() { + if (typeof Reflect === 'object' && Reflect && Reflect.getPrototypeOf) { + return Reflect.getPrototypeOf; + } + return getProto + ? function getPrototypeOf(O) { return getProto(O); } + : implementation; +}; diff --git a/tools/ui/node_modules/reflect.getprototypeof/shim.js b/tools/ui/node_modules/reflect.getprototypeof/shim.js new file mode 100644 index 0000000000000000000000000000000000000000..1724eb2c02cf1159a8f4532565b99989bb472ea7 --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/shim.js @@ -0,0 +1,21 @@ +'use strict'; + +var define = require('define-properties'); +var getPolyfill = require('./polyfill'); + +module.exports = function shimGetPrototypeOf() { + define( + global, + { Reflect: {} }, + { Reflect: function () { return typeof Reflect !== 'object' || !Reflect; } } + ); + + var polyfill = getPolyfill(); + define( + Reflect, + { getPrototypeOf: polyfill }, + { getPrototypeOf: function () { return Reflect.getPrototypeOf !== polyfill; } } + ); + + return polyfill; +}; diff --git a/tools/ui/node_modules/reflect.getprototypeof/test/implementation.js b/tools/ui/node_modules/reflect.getprototypeof/test/implementation.js new file mode 100644 index 0000000000000000000000000000000000000000..8992d3d3b2074b13c21c7664f11fa3778298afd6 --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/test/implementation.js @@ -0,0 +1,11 @@ +'use strict'; + +var getPrototypeOf = require('../implementation'); +var test = require('tape'); +var runTests = require('./tests'); + +test('as a function', function (t) { + runTests(getPrototypeOf, t); + + t.end(); +}); diff --git a/tools/ui/node_modules/reflect.getprototypeof/test/index.js b/tools/ui/node_modules/reflect.getprototypeof/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..0492e7d639606ac676e93505fabbb7c5cbe6c4ca --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/test/index.js @@ -0,0 +1,11 @@ +'use strict'; + +var getPrototypeOf = require('../'); +var test = require('tape'); +var runTests = require('./tests'); + +test('as a function', function (t) { + runTests(getPrototypeOf, t); + + t.end(); +}); diff --git a/tools/ui/node_modules/reflect.getprototypeof/test/shimmed.js b/tools/ui/node_modules/reflect.getprototypeof/test/shimmed.js new file mode 100644 index 0000000000000000000000000000000000000000..c3de97e29170eb36c34921d0210b24bcafb01e4c --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/test/shimmed.js @@ -0,0 +1,28 @@ +'use strict'; + +require('../auto'); + +var test = require('tape'); +var defineProperties = require('define-properties'); + +var isEnumerable = Object.prototype.propertyIsEnumerable; +var functionsHaveNames = require('functions-have-names')(); + +var runTests = require('./tests'); + +test('shimmed', function (t) { + t.equal(Reflect.getPrototypeOf.length, 1, 'Reflect.getPrototypeOf has length of 1'); + t.test('Function name', { skip: !functionsHaveNames }, function (st) { + st.equal(Reflect.getPrototypeOf.name, 'getPrototypeOf', 'Reflect.getPrototypeOf has name "getPrototypeOf"'); + st.end(); + }); + + t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) { + et.equal(false, isEnumerable.call(Reflect, 'getPrototypeOf'), 'Reflect.getPrototypeOf is not enumerable'); + et.end(); + }); + + runTests(Reflect.getPrototypeOf, t); + + t.end(); +}); diff --git a/tools/ui/node_modules/reflect.getprototypeof/test/tests.js b/tools/ui/node_modules/reflect.getprototypeof/test/tests.js new file mode 100644 index 0000000000000000000000000000000000000000..508d923edb6fb6fb57cf2e87c2cadafb1305c727 --- /dev/null +++ b/tools/ui/node_modules/reflect.getprototypeof/test/tests.js @@ -0,0 +1,33 @@ +'use strict'; + +module.exports = function (getPrototypeOf, t) { + t.test('nullish value', function (st) { + st['throws'](function () { return getPrototypeOf(undefined); }, TypeError, 'undefined is not an object'); + st['throws'](function () { return getPrototypeOf(null); }, TypeError, 'null is not an object'); + st.end(); + }); + + t['throws'](function () { getPrototypeOf(true); }, 'throws for true'); + t['throws'](function () { getPrototypeOf(false); }, 'throws for false'); + t['throws'](function () { getPrototypeOf(42); }, 'throws for 42'); + t['throws'](function () { getPrototypeOf(NaN); }, 'throws for NaN'); + t['throws'](function () { getPrototypeOf(0); }, 'throws for +0'); + t['throws'](function () { getPrototypeOf(-0); }, 'throws for -0'); + t['throws'](function () { getPrototypeOf(Infinity); }, 'throws for ∞'); + t['throws'](function () { getPrototypeOf(-Infinity); }, 'throws for -∞'); + t['throws'](function () { getPrototypeOf(''); }, 'throws for empty string'); + t['throws'](function () { getPrototypeOf('foo'); }, 'throws for non-empty string'); + t.equal(getPrototypeOf(/a/g), RegExp.prototype); + t.equal(getPrototypeOf(new Date()), Date.prototype); + t.equal(getPrototypeOf(function () {}), Function.prototype); + t.equal(getPrototypeOf([]), Array.prototype); + t.equal(getPrototypeOf({}), Object.prototype); + + var obj = { __proto__: null }; + if ('toString' in obj) { + t.comment('no null objects in this engine'); + t.equal(getPrototypeOf(obj), Object.prototype, '"null" object has Object.prototype as [[Prototype]]'); + } else { + t.equal(getPrototypeOf(obj), null, 'null object has null [[Prototype]]'); + } +}; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/ASCII.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/ASCII.js new file mode 100644 index 0000000000000000000000000000000000000000..ba468d14f7c610ac84eea0e3a49dca0c3dfa4c44 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/ASCII.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x0, 0x7F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/ASCII_Hex_Digit.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/ASCII_Hex_Digit.js new file mode 100644 index 0000000000000000000000000000000000000000..222bb5c5f1a102702d69dda052ef396baad85aa8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/ASCII_Hex_Digit.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x30, 0x39).addRange(0x41, 0x46).addRange(0x61, 0x66); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Alphabetic.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Alphabetic.js new file mode 100644 index 0000000000000000000000000000000000000000..e47fb2a8380e53846bbfbecfcfba46ec07a8dfc6 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Alphabetic.js @@ -0,0 +1,15 @@ +const set = require('regenerate')(0xAA, 0xB5, 0xBA, 0x2EC, 0x2EE, 0x345, 0x37F, 0x386, 0x38C, 0x559, 0x5BF, 0x5C7, 0x6FF, 0x7FA, 0x897, 0x9B2, 0x9CE, 0x9D7, 0x9FC, 0xA51, 0xA5E, 0xAD0, 0xB71, 0xB9C, 0xBD0, 0xBD7, 0xD4E, 0xDBD, 0xDD6, 0xE4D, 0xE84, 0xEA5, 0xEC6, 0xECD, 0xF00, 0x1038, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x17DC, 0x1AA7, 0x1CFA, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2071, 0x207F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214E, 0x2D27, 0x2D2D, 0x2D6F, 0x2E2F, 0xA8C5, 0xA8FB, 0xA9CF, 0xAAC0, 0xAAC2, 0xFB3E, 0x10808, 0x1083C, 0x10D69, 0x10F27, 0x110C2, 0x11176, 0x111DA, 0x111DC, 0x11237, 0x11288, 0x11350, 0x11357, 0x1138B, 0x1138E, 0x113C2, 0x113C5, 0x113D1, 0x113D3, 0x114C7, 0x11640, 0x11644, 0x116B8, 0x11909, 0x119E1, 0x11A9D, 0x11C40, 0x11D3A, 0x11D43, 0x11D98, 0x11FB0, 0x16FE3, 0x1B132, 0x1B155, 0x1BC9E, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1E08F, 0x1E14E, 0x1E5F0, 0x1E947, 0x1E94B, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E); +set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x363, 0x374).addRange(0x376, 0x377).addRange(0x37A, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x5B0, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x610, 0x61A).addRange(0x620, 0x657).addRange(0x659, 0x65F).addRange(0x66E, 0x6D3).addRange(0x6D5, 0x6DC).addRange(0x6E1, 0x6E8).addRange(0x6ED, 0x6EF).addRange(0x6FA, 0x6FC).addRange(0x710, 0x73F).addRange(0x74D, 0x7B1).addRange(0x7CA, 0x7EA).addRange(0x7F4, 0x7F5).addRange(0x800, 0x817).addRange(0x81A, 0x82C).addRange(0x840, 0x858).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88F).addRange(0x8A0, 0x8C9).addRange(0x8D4, 0x8DF).addRange(0x8E3, 0x8E9).addRange(0x8F0, 0x93B).addRange(0x93D, 0x94C).addRange(0x94E, 0x950).addRange(0x955, 0x963).addRange(0x971, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8); +set.addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BD, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CC).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E3).addRange(0x9F0, 0x9F1).addRange(0xA01, 0xA03).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4C).addRange(0xA59, 0xA5C).addRange(0xA70, 0xA75).addRange(0xA81, 0xA83).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABD, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACC).addRange(0xAE0, 0xAE3).addRange(0xAF9, 0xAFC).addRange(0xB01, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB3D, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4C).addRange(0xB56, 0xB57).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB63).addRange(0xB82, 0xB83).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A); +set.addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCC).addRange(0xC00, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC3D, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4C).addRange(0xC55, 0xC56).addRange(0xC58, 0xC5A).addRange(0xC5C, 0xC5D).addRange(0xC60, 0xC63).addRange(0xC80, 0xC83).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCBD, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCC).addRange(0xCD5, 0xCD6).addRange(0xCDC, 0xCDE).addRange(0xCE0, 0xCE3).addRange(0xCF1, 0xCF3).addRange(0xD00, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD3A).addRange(0xD3D, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4C).addRange(0xD54, 0xD57).addRange(0xD5F, 0xD63).addRange(0xD7A, 0xD7F).addRange(0xD81, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDF2, 0xDF3).addRange(0xE01, 0xE3A).addRange(0xE40, 0xE46).addRange(0xE81, 0xE82); +set.addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEB9).addRange(0xEBB, 0xEBD).addRange(0xEC0, 0xEC4).addRange(0xEDC, 0xEDF).addRange(0xF40, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF71, 0xF83).addRange(0xF88, 0xF97).addRange(0xF99, 0xFBC).addRange(0x1000, 0x1036).addRange(0x103B, 0x103F).addRange(0x1050, 0x108F).addRange(0x109A, 0x109D).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x1380, 0x138F).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16EE, 0x16F8).addRange(0x1700, 0x1713).addRange(0x171F, 0x1733).addRange(0x1740, 0x1753).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1772, 0x1773).addRange(0x1780, 0x17B3).addRange(0x17B6, 0x17C8).addRange(0x1820, 0x1878).addRange(0x1880, 0x18AA).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E); +set.addRange(0x1920, 0x192B).addRange(0x1930, 0x1938).addRange(0x1950, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x1A00, 0x1A1B).addRange(0x1A20, 0x1A5E).addRange(0x1A61, 0x1A74).addRange(0x1ABF, 0x1AC0).addRange(0x1ACC, 0x1ACE).addRange(0x1B00, 0x1B33).addRange(0x1B35, 0x1B43).addRange(0x1B45, 0x1B4C).addRange(0x1B80, 0x1BA9).addRange(0x1BAC, 0x1BAF).addRange(0x1BBA, 0x1BE5).addRange(0x1BE7, 0x1BF1).addRange(0x1C00, 0x1C36).addRange(0x1C4D, 0x1C4F).addRange(0x1C5A, 0x1C7D).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF6).addRange(0x1D00, 0x1DBF).addRange(0x1DD3, 0x1DF4).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x2090, 0x209C).addRange(0x210A, 0x2113).addRange(0x2119, 0x211D).addRange(0x212A, 0x212D).addRange(0x212F, 0x2139).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149); +set.addRange(0x2160, 0x2188).addRange(0x24B6, 0x24E9).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x2DE0, 0x2DFF).addRange(0x3005, 0x3007).addRange(0x3021, 0x3029).addRange(0x3031, 0x3035).addRange(0x3038, 0x303C).addRange(0x3041, 0x3096).addRange(0x309D, 0x309F).addRange(0x30A1, 0x30FA).addRange(0x30FC, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA48C).addRange(0xA4D0, 0xA4FD).addRange(0xA500, 0xA60C).addRange(0xA610, 0xA61F).addRange(0xA62A, 0xA62B).addRange(0xA640, 0xA66E).addRange(0xA674, 0xA67B).addRange(0xA67F, 0xA6EF).addRange(0xA717, 0xA71F).addRange(0xA722, 0xA788).addRange(0xA78B, 0xA7DC).addRange(0xA7F1, 0xA805).addRange(0xA807, 0xA827).addRange(0xA840, 0xA873).addRange(0xA880, 0xA8C3).addRange(0xA8F2, 0xA8F7).addRange(0xA8FD, 0xA8FF).addRange(0xA90A, 0xA92A).addRange(0xA930, 0xA952).addRange(0xA960, 0xA97C).addRange(0xA980, 0xA9B2); +set.addRange(0xA9B4, 0xA9BF).addRange(0xA9E0, 0xA9EF).addRange(0xA9FA, 0xA9FE).addRange(0xAA00, 0xAA36).addRange(0xAA40, 0xAA4D).addRange(0xAA60, 0xAA76).addRange(0xAA7A, 0xAABE).addRange(0xAADB, 0xAADD).addRange(0xAAE0, 0xAAEF).addRange(0xAAF2, 0xAAF5).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABEA).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1D, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFB).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0xFF66, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA); +set.addRange(0x10140, 0x10174).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x10300, 0x1031F).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x1037A).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x103D1, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915).addRange(0x10920, 0x10939).addRange(0x10940, 0x10959).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A00, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7); +set.addRange(0x10AC9, 0x10AE4).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91).addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D00, 0x10D27).addRange(0x10D4A, 0x10D65).addRange(0x10D6F, 0x10D85).addRange(0x10E80, 0x10EA9).addRange(0x10EAB, 0x10EAC).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC7).addRange(0x10EFA, 0x10EFC).addRange(0x10F00, 0x10F1C).addRange(0x10F30, 0x10F45).addRange(0x10F70, 0x10F81).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11000, 0x11045).addRange(0x11071, 0x11075).addRange(0x11080, 0x110B8).addRange(0x110D0, 0x110E8).addRange(0x11100, 0x11132).addRange(0x11144, 0x11147).addRange(0x11150, 0x11172).addRange(0x11180, 0x111BF).addRange(0x111C1, 0x111C4).addRange(0x111CE, 0x111CF).addRange(0x11200, 0x11211).addRange(0x11213, 0x11234).addRange(0x1123E, 0x11241).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112E8).addRange(0x11300, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1133D, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134C).addRange(0x1135D, 0x11363).addRange(0x11380, 0x11389); +set.addRange(0x11390, 0x113B5).addRange(0x113B7, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113CD).addRange(0x11400, 0x11441).addRange(0x11443, 0x11445).addRange(0x11447, 0x1144A).addRange(0x1145F, 0x11461).addRange(0x11480, 0x114C1).addRange(0x114C4, 0x114C5).addRange(0x11580, 0x115B5).addRange(0x115B8, 0x115BE).addRange(0x115D8, 0x115DD).addRange(0x11600, 0x1163E).addRange(0x11680, 0x116B5).addRange(0x11700, 0x1171A).addRange(0x1171D, 0x1172A).addRange(0x11740, 0x11746).addRange(0x11800, 0x11838).addRange(0x118A0, 0x118DF).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x1193C).addRange(0x1193F, 0x11942).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D7).addRange(0x119DA, 0x119DF).addRange(0x119E3, 0x119E4).addRange(0x11A00, 0x11A32).addRange(0x11A35, 0x11A3E).addRange(0x11A50, 0x11A97).addRange(0x11AB0, 0x11AF8).addRange(0x11B60, 0x11B67).addRange(0x11BC0, 0x11BE0).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C36).addRange(0x11C38, 0x11C3E).addRange(0x11C72, 0x11C8F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D41).addRange(0x11D46, 0x11D47).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68); +set.addRange(0x11D6A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D96).addRange(0x11DB0, 0x11DDB).addRange(0x11EE0, 0x11EF6).addRange(0x11F00, 0x11F10).addRange(0x11F12, 0x11F3A).addRange(0x11F3E, 0x11F40).addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13441, 0x13446).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x1612E).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A70, 0x16ABE).addRange(0x16AD0, 0x16AED).addRange(0x16B00, 0x16B2F).addRange(0x16B40, 0x16B43).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D6C).addRange(0x16E40, 0x16E7F).addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3).addRange(0x16F00, 0x16F4A).addRange(0x16F4F, 0x16F87).addRange(0x16F8F, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x16FF0, 0x16FF6).addRange(0x17000, 0x18CD5).addRange(0x18CFF, 0x18D1E).addRange(0x18D80, 0x18DF2).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F); +set.addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E137, 0x1E13D).addRange(0x1E290, 0x1E2AD).addRange(0x1E2C0, 0x1E2EB).addRange(0x1E4D0, 0x1E4EB).addRange(0x1E5D0, 0x1E5ED).addRange(0x1E6C0, 0x1E6DE).addRange(0x1E6E0, 0x1E6F5).addRange(0x1E6FE, 0x1E6FF).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E900, 0x1E943).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32); +set.addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1F130, 0x1F149).addRange(0x1F150, 0x1F169).addRange(0x1F170, 0x1F189).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Any.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Any.js new file mode 100644 index 0000000000000000000000000000000000000000..4810e325bcad79beb984ba5ed9ac768bb6ae08dc --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Any.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x0, 0x10FFFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Assigned.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Assigned.js new file mode 100644 index 0000000000000000000000000000000000000000..29dbea191b81acfaca87a5280f96717d71a4f774 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Assigned.js @@ -0,0 +1,16 @@ +const set = require('regenerate')(0x38C, 0x85E, 0x9B2, 0x9D7, 0xA3C, 0xA51, 0xA5E, 0xAD0, 0xB9C, 0xBD0, 0xBD7, 0xDBD, 0xDCA, 0xDD6, 0xE84, 0xEA5, 0xEC6, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x1940, 0x1F59, 0x1F5B, 0x1F5D, 0x2D27, 0x2D2D, 0xFB3E, 0xFEFF, 0x101A0, 0x10808, 0x1083C, 0x110CD, 0x11288, 0x11350, 0x11357, 0x1138B, 0x1138E, 0x113C2, 0x113C5, 0x11909, 0x11D3A, 0x11FB0, 0x1B132, 0x1B155, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1E08F, 0x1E2FF, 0x1E5FF, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E, 0x1F7F0, 0x1FAC8, 0xE0001); +set.addRange(0x0, 0x377).addRange(0x37A, 0x37F).addRange(0x384, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x52F).addRange(0x531, 0x556).addRange(0x559, 0x58A).addRange(0x58D, 0x58F).addRange(0x591, 0x5C7).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F4).addRange(0x600, 0x70D).addRange(0x70F, 0x74A).addRange(0x74D, 0x7B1).addRange(0x7C0, 0x7FA).addRange(0x7FD, 0x82D).addRange(0x830, 0x83E).addRange(0x840, 0x85B).addRange(0x860, 0x86A).addRange(0x870, 0x891).addRange(0x897, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BC, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CE).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E3).addRange(0x9E6, 0x9FE).addRange(0xA01, 0xA03).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA59, 0xA5C).addRange(0xA66, 0xA76).addRange(0xA81, 0xA83).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3); +set.addRange(0xAB5, 0xAB9).addRange(0xABC, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACD).addRange(0xAE0, 0xAE3).addRange(0xAE6, 0xAF1).addRange(0xAF9, 0xAFF).addRange(0xB01, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB3C, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4D).addRange(0xB55, 0xB57).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB63).addRange(0xB66, 0xB77).addRange(0xB82, 0xB83).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCD).addRange(0xBE6, 0xBFA).addRange(0xC00, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC3C, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC58, 0xC5A).addRange(0xC5C, 0xC5D).addRange(0xC60, 0xC63).addRange(0xC66, 0xC6F).addRange(0xC77, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9); +set.addRange(0xCBC, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCDC, 0xCDE).addRange(0xCE0, 0xCE3).addRange(0xCE6, 0xCEF).addRange(0xCF1, 0xCF3).addRange(0xD00, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4F).addRange(0xD54, 0xD63).addRange(0xD66, 0xD7F).addRange(0xD81, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDE6, 0xDEF).addRange(0xDF2, 0xDF4).addRange(0xE01, 0xE3A).addRange(0xE3F, 0xE5B).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEBD).addRange(0xEC0, 0xEC4).addRange(0xEC8, 0xECE).addRange(0xED0, 0xED9).addRange(0xEDC, 0xEDF).addRange(0xF00, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF71, 0xF97).addRange(0xF99, 0xFBC).addRange(0xFBE, 0xFCC).addRange(0xFCE, 0xFDA).addRange(0x1000, 0x10C5).addRange(0x10D0, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5); +set.addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x135D, 0x137C).addRange(0x1380, 0x1399).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1400, 0x169C).addRange(0x16A0, 0x16F8).addRange(0x1700, 0x1715).addRange(0x171F, 0x1736).addRange(0x1740, 0x1753).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1772, 0x1773).addRange(0x1780, 0x17DD).addRange(0x17E0, 0x17E9).addRange(0x17F0, 0x17F9).addRange(0x1800, 0x1819).addRange(0x1820, 0x1878).addRange(0x1880, 0x18AA).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1920, 0x192B).addRange(0x1930, 0x193B).addRange(0x1944, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x19D0, 0x19DA).addRange(0x19DE, 0x1A1B).addRange(0x1A1E, 0x1A5E).addRange(0x1A60, 0x1A7C).addRange(0x1A7F, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1AA0, 0x1AAD).addRange(0x1AB0, 0x1ADD).addRange(0x1AE0, 0x1AEB).addRange(0x1B00, 0x1B4C).addRange(0x1B4E, 0x1BF3).addRange(0x1BFC, 0x1C37).addRange(0x1C3B, 0x1C49).addRange(0x1C4D, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CC7).addRange(0x1CD0, 0x1CFA).addRange(0x1D00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D); +set.addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FC4).addRange(0x1FC6, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FDD, 0x1FEF).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFE).addRange(0x2000, 0x2064).addRange(0x2066, 0x2071).addRange(0x2074, 0x208E).addRange(0x2090, 0x209C).addRange(0x20A0, 0x20C1).addRange(0x20D0, 0x20F0).addRange(0x2100, 0x218B).addRange(0x2190, 0x2429).addRange(0x2440, 0x244A).addRange(0x2460, 0x2B73).addRange(0x2B76, 0x2CF3).addRange(0x2CF9, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D6F, 0x2D70).addRange(0x2D7F, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x2DE0, 0x2E5D).addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5).addRange(0x2FF0, 0x303F).addRange(0x3041, 0x3096).addRange(0x3099, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x3190, 0x31E5).addRange(0x31EF, 0x321E).addRange(0x3220, 0xA48C).addRange(0xA490, 0xA4C6).addRange(0xA4D0, 0xA62B).addRange(0xA640, 0xA6F7).addRange(0xA700, 0xA7DC).addRange(0xA7F1, 0xA82C).addRange(0xA830, 0xA839).addRange(0xA840, 0xA877); +set.addRange(0xA880, 0xA8C5).addRange(0xA8CE, 0xA8D9).addRange(0xA8E0, 0xA953).addRange(0xA95F, 0xA97C).addRange(0xA980, 0xA9CD).addRange(0xA9CF, 0xA9D9).addRange(0xA9DE, 0xA9FE).addRange(0xAA00, 0xAA36).addRange(0xAA40, 0xAA4D).addRange(0xAA50, 0xAA59).addRange(0xAA5C, 0xAAC2).addRange(0xAADB, 0xAAF6).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB6B).addRange(0xAB70, 0xABED).addRange(0xABF0, 0xABF9).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xD800, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1D, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFDCF).addRange(0xFDF0, 0xFE19).addRange(0xFE20, 0xFE52).addRange(0xFE54, 0xFE66).addRange(0xFE68, 0xFE6B).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF01, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0xFFE0, 0xFFE6).addRange(0xFFE8, 0xFFEE).addRange(0xFFF9, 0xFFFD).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D); +set.addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10100, 0x10102).addRange(0x10107, 0x10133).addRange(0x10137, 0x1018E).addRange(0x10190, 0x1019C).addRange(0x101D0, 0x101FD).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x102E0, 0x102FB).addRange(0x10300, 0x10323).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x1037A).addRange(0x10380, 0x1039D).addRange(0x1039F, 0x103C3).addRange(0x103C8, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104A0, 0x104A9).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x1056F, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10857, 0x1089E).addRange(0x108A7, 0x108AF).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x108FB, 0x1091B).addRange(0x1091F, 0x10939).addRange(0x1093F, 0x10959).addRange(0x10980, 0x109B7).addRange(0x109BC, 0x109CF).addRange(0x109D2, 0x10A03); +set.addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A38, 0x10A3A).addRange(0x10A3F, 0x10A48).addRange(0x10A50, 0x10A58).addRange(0x10A60, 0x10A9F).addRange(0x10AC0, 0x10AE6).addRange(0x10AEB, 0x10AF6).addRange(0x10B00, 0x10B35).addRange(0x10B39, 0x10B55).addRange(0x10B58, 0x10B72).addRange(0x10B78, 0x10B91).addRange(0x10B99, 0x10B9C).addRange(0x10BA9, 0x10BAF).addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10CFA, 0x10D27).addRange(0x10D30, 0x10D39).addRange(0x10D40, 0x10D65).addRange(0x10D69, 0x10D85).addRange(0x10D8E, 0x10D8F).addRange(0x10E60, 0x10E7E).addRange(0x10E80, 0x10EA9).addRange(0x10EAB, 0x10EAD).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC7).addRange(0x10ED0, 0x10ED8).addRange(0x10EFA, 0x10F27).addRange(0x10F30, 0x10F59).addRange(0x10F70, 0x10F89).addRange(0x10FB0, 0x10FCB).addRange(0x10FE0, 0x10FF6).addRange(0x11000, 0x1104D).addRange(0x11052, 0x11075).addRange(0x1107F, 0x110C2).addRange(0x110D0, 0x110E8).addRange(0x110F0, 0x110F9).addRange(0x11100, 0x11134).addRange(0x11136, 0x11147).addRange(0x11150, 0x11176).addRange(0x11180, 0x111DF).addRange(0x111E1, 0x111F4).addRange(0x11200, 0x11211).addRange(0x11213, 0x11241).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A9); +set.addRange(0x112B0, 0x112EA).addRange(0x112F0, 0x112F9).addRange(0x11300, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1133B, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x1135D, 0x11363).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x113B7, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113D5).addRange(0x113D7, 0x113D8).addRange(0x113E1, 0x113E2).addRange(0x11400, 0x1145B).addRange(0x1145D, 0x11461).addRange(0x11480, 0x114C7).addRange(0x114D0, 0x114D9).addRange(0x11580, 0x115B5).addRange(0x115B8, 0x115DD).addRange(0x11600, 0x11644).addRange(0x11650, 0x11659).addRange(0x11660, 0x1166C).addRange(0x11680, 0x116B9).addRange(0x116C0, 0x116C9).addRange(0x116D0, 0x116E3).addRange(0x11700, 0x1171A).addRange(0x1171D, 0x1172B).addRange(0x11730, 0x11746).addRange(0x11800, 0x1183B).addRange(0x118A0, 0x118F2).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x11946).addRange(0x11950, 0x11959).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D7).addRange(0x119DA, 0x119E4).addRange(0x11A00, 0x11A47).addRange(0x11A50, 0x11AA2); +set.addRange(0x11AB0, 0x11AF8).addRange(0x11B00, 0x11B09).addRange(0x11B60, 0x11B67).addRange(0x11BC0, 0x11BE1).addRange(0x11BF0, 0x11BF9).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C36).addRange(0x11C38, 0x11C45).addRange(0x11C50, 0x11C6C).addRange(0x11C70, 0x11C8F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D47).addRange(0x11D50, 0x11D59).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D98).addRange(0x11DA0, 0x11DA9).addRange(0x11DB0, 0x11DDB).addRange(0x11DE0, 0x11DE9).addRange(0x11EE0, 0x11EF8).addRange(0x11F00, 0x11F10).addRange(0x11F12, 0x11F3A).addRange(0x11F3E, 0x11F5A).addRange(0x11FC0, 0x11FF1).addRange(0x11FFF, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12470, 0x12474).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF2).addRange(0x13000, 0x13455).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x16139).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A60, 0x16A69).addRange(0x16A6E, 0x16ABE).addRange(0x16AC0, 0x16AC9).addRange(0x16AD0, 0x16AED).addRange(0x16AF0, 0x16AF5).addRange(0x16B00, 0x16B45).addRange(0x16B50, 0x16B59).addRange(0x16B5B, 0x16B61).addRange(0x16B63, 0x16B77); +set.addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D79).addRange(0x16E40, 0x16E9A).addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3).addRange(0x16F00, 0x16F4A).addRange(0x16F4F, 0x16F87).addRange(0x16F8F, 0x16F9F).addRange(0x16FE0, 0x16FE4).addRange(0x16FF0, 0x16FF6).addRange(0x17000, 0x18CD5).addRange(0x18CFF, 0x18D1E).addRange(0x18D80, 0x18DF2).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1BC9C, 0x1BCA3).addRange(0x1CC00, 0x1CCFC).addRange(0x1CD00, 0x1CEB3).addRange(0x1CEBA, 0x1CED0).addRange(0x1CEE0, 0x1CEF0).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1CF50, 0x1CFC3).addRange(0x1D000, 0x1D0F5).addRange(0x1D100, 0x1D126).addRange(0x1D129, 0x1D1EA).addRange(0x1D200, 0x1D245).addRange(0x1D2C0, 0x1D2D3).addRange(0x1D2E0, 0x1D2F3).addRange(0x1D300, 0x1D356).addRange(0x1D360, 0x1D378).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C); +set.addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D7CB).addRange(0x1D7CE, 0x1DA8B).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E130, 0x1E13D).addRange(0x1E140, 0x1E149).addRange(0x1E14E, 0x1E14F).addRange(0x1E290, 0x1E2AE).addRange(0x1E2C0, 0x1E2F9).addRange(0x1E4D0, 0x1E4F9).addRange(0x1E5D0, 0x1E5FA).addRange(0x1E6C0, 0x1E6DE).addRange(0x1E6E0, 0x1E6F5).addRange(0x1E6FE, 0x1E6FF).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E8C7, 0x1E8D6).addRange(0x1E900, 0x1E94B).addRange(0x1E950, 0x1E959).addRange(0x1E95E, 0x1E95F).addRange(0x1EC71, 0x1ECB4).addRange(0x1ED01, 0x1ED3D).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C); +set.addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1EEF0, 0x1EEF1).addRange(0x1F000, 0x1F02B).addRange(0x1F030, 0x1F093).addRange(0x1F0A0, 0x1F0AE).addRange(0x1F0B1, 0x1F0BF).addRange(0x1F0C1, 0x1F0CF).addRange(0x1F0D1, 0x1F0F5).addRange(0x1F100, 0x1F1AD).addRange(0x1F1E6, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F250, 0x1F251).addRange(0x1F260, 0x1F265).addRange(0x1F300, 0x1F6D8).addRange(0x1F6DC, 0x1F6EC).addRange(0x1F6F0, 0x1F6FC).addRange(0x1F700, 0x1F7D9).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F800, 0x1F80B).addRange(0x1F810, 0x1F847).addRange(0x1F850, 0x1F859).addRange(0x1F860, 0x1F887).addRange(0x1F890, 0x1F8AD).addRange(0x1F8B0, 0x1F8BB).addRange(0x1F8C0, 0x1F8C1).addRange(0x1F8D0, 0x1F8D8).addRange(0x1F900, 0x1FA57).addRange(0x1FA60, 0x1FA6D).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA8A).addRange(0x1FA8E, 0x1FAC6).addRange(0x1FACD, 0x1FADC).addRange(0x1FADF, 0x1FAEA).addRange(0x1FAEF, 0x1FAF8).addRange(0x1FB00, 0x1FB92).addRange(0x1FB94, 0x1FBFA).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479).addRange(0xE0020, 0xE007F).addRange(0xE0100, 0xE01EF); +set.addRange(0xF0000, 0xFFFFD).addRange(0x100000, 0x10FFFD); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Bidi_Control.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Bidi_Control.js new file mode 100644 index 0000000000000000000000000000000000000000..03914c49da8f919fca8a7b0ea432ce22b40ccefd --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Bidi_Control.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x61C); +set.addRange(0x200E, 0x200F).addRange(0x202A, 0x202E).addRange(0x2066, 0x2069); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Bidi_Mirrored.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Bidi_Mirrored.js new file mode 100644 index 0000000000000000000000000000000000000000..b07111624a715649033325cd717df0036197b6ba --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Bidi_Mirrored.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0x3C, 0x3E, 0x5B, 0x5D, 0x7B, 0x7D, 0xAB, 0xBB, 0x2140, 0x2211, 0x2224, 0x2226, 0x2239, 0x2262, 0x2298, 0x27C0, 0x29B8, 0x29C9, 0x29E1, 0x2A24, 0x2A26, 0x2A29, 0x2ADC, 0x2ADE, 0x2AF3, 0x2AFD, 0x2BFE, 0xFF1C, 0xFF1E, 0xFF3B, 0xFF3D, 0xFF5B, 0xFF5D, 0x1D6DB, 0x1D715, 0x1D74F, 0x1D789, 0x1D7C3); +set.addRange(0x28, 0x29).addRange(0xF3A, 0xF3D).addRange(0x169B, 0x169C).addRange(0x2039, 0x203A).addRange(0x2045, 0x2046).addRange(0x207D, 0x207E).addRange(0x208D, 0x208E).addRange(0x2201, 0x2204).addRange(0x2208, 0x220D).addRange(0x2215, 0x2216).addRange(0x221A, 0x221D).addRange(0x221F, 0x2222).addRange(0x222B, 0x2233).addRange(0x223B, 0x224C).addRange(0x2252, 0x2255).addRange(0x225F, 0x2260).addRange(0x2264, 0x226B).addRange(0x226D, 0x228C).addRange(0x228F, 0x2292).addRange(0x22A2, 0x22A3).addRange(0x22A6, 0x22B8).addRange(0x22BE, 0x22BF).addRange(0x22C9, 0x22CD).addRange(0x22D0, 0x22D1).addRange(0x22D6, 0x22ED).addRange(0x22F0, 0x22FF).addRange(0x2308, 0x230B).addRange(0x2320, 0x2321).addRange(0x2329, 0x232A).addRange(0x2768, 0x2775).addRange(0x27C3, 0x27C6).addRange(0x27C8, 0x27C9).addRange(0x27CB, 0x27CD).addRange(0x27D3, 0x27D6).addRange(0x27DC, 0x27DE).addRange(0x27E2, 0x27EF).addRange(0x2983, 0x2998).addRange(0x299B, 0x29A0).addRange(0x29A2, 0x29AF).addRange(0x29C0, 0x29C5).addRange(0x29CE, 0x29D2).addRange(0x29D4, 0x29D5).addRange(0x29D8, 0x29DC).addRange(0x29E3, 0x29E5).addRange(0x29E8, 0x29E9).addRange(0x29F4, 0x29F9).addRange(0x29FC, 0x29FD).addRange(0x2A0A, 0x2A1C).addRange(0x2A1E, 0x2A21).addRange(0x2A2B, 0x2A2E).addRange(0x2A34, 0x2A35); +set.addRange(0x2A3C, 0x2A3E).addRange(0x2A57, 0x2A58).addRange(0x2A64, 0x2A65).addRange(0x2A6A, 0x2A6D).addRange(0x2A6F, 0x2A70).addRange(0x2A73, 0x2A74).addRange(0x2A79, 0x2AA3).addRange(0x2AA6, 0x2AAD).addRange(0x2AAF, 0x2AD6).addRange(0x2AE2, 0x2AE6).addRange(0x2AEC, 0x2AEE).addRange(0x2AF7, 0x2AFB).addRange(0x2E02, 0x2E05).addRange(0x2E09, 0x2E0A).addRange(0x2E0C, 0x2E0D).addRange(0x2E1C, 0x2E1D).addRange(0x2E20, 0x2E29).addRange(0x2E55, 0x2E5C).addRange(0x3008, 0x3011).addRange(0x3014, 0x301B).addRange(0xFE59, 0xFE5E).addRange(0xFE64, 0xFE65).addRange(0xFF08, 0xFF09).addRange(0xFF5F, 0xFF60).addRange(0xFF62, 0xFF63); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Case_Ignorable.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Case_Ignorable.js new file mode 100644 index 0000000000000000000000000000000000000000..9a37d95e4f865528126a7bdba0b3a64093d07b1e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Case_Ignorable.js @@ -0,0 +1,8 @@ +const set = require('regenerate')(0x27, 0x2E, 0x3A, 0x5E, 0x60, 0xA8, 0xAD, 0xAF, 0xB4, 0x37A, 0x387, 0x559, 0x55F, 0x5BF, 0x5C7, 0x5F4, 0x61C, 0x640, 0x670, 0x70F, 0x711, 0x7FA, 0x7FD, 0x888, 0x93A, 0x93C, 0x94D, 0x971, 0x981, 0x9BC, 0x9CD, 0x9FE, 0xA3C, 0xA51, 0xA75, 0xABC, 0xACD, 0xB01, 0xB3C, 0xB3F, 0xB4D, 0xB82, 0xBC0, 0xBCD, 0xC00, 0xC04, 0xC3C, 0xC81, 0xCBC, 0xCBF, 0xCC6, 0xD4D, 0xD81, 0xDCA, 0xDD6, 0xE31, 0xEB1, 0xEC6, 0xF35, 0xF37, 0xF39, 0xFC6, 0x1082, 0x108D, 0x109D, 0x10FC, 0x17C6, 0x17D7, 0x17DD, 0x1843, 0x18A9, 0x1932, 0x1A1B, 0x1A56, 0x1A60, 0x1A62, 0x1A7F, 0x1AA7, 0x1B34, 0x1B3C, 0x1B42, 0x1BE6, 0x1BED, 0x1CED, 0x1CF4, 0x1D78, 0x1FBD, 0x2024, 0x2027, 0x2071, 0x207F, 0x2D6F, 0x2D7F, 0x2E2F, 0x3005, 0x303B, 0xA015, 0xA60C, 0xA67F, 0xA770, 0xA802, 0xA806, 0xA80B, 0xA82C, 0xA8FF, 0xA9B3, 0xA9CF, 0xAA43, 0xAA4C, 0xAA70, 0xAA7C, 0xAAB0, 0xAAC1, 0xAADD, 0xAAF6, 0xABE5, 0xABE8, 0xABED, 0xFB1E, 0xFE13, 0xFE52, 0xFE55, 0xFEFF, 0xFF07, 0xFF0E, 0xFF1A, 0xFF3E, 0xFF40, 0xFF70, 0xFFE3, 0x101FD, 0x102E0, 0x10A3F, 0x10D4E, 0x10D6F, 0x10EC5, 0x11001, 0x11070, 0x110BD, 0x110C2, 0x110CD, 0x11173, 0x111CF, 0x11234, 0x1123E, 0x11241, 0x112DF, 0x11340, 0x113CE, 0x113D0, 0x113D2, 0x11446, 0x1145E, 0x114BA, 0x1163D, 0x116AB, 0x116AD, 0x116B7, 0x1171D, 0x1171F, 0x1193E, 0x11943, 0x119E0, 0x11A47, 0x11B60, 0x11B66, 0x11C3F, 0x11D3A, 0x11D47, 0x11D95, 0x11D97, 0x11DD9, 0x11F40, 0x11F42, 0x11F5A, 0x16F4F, 0x1DA75, 0x1DA84, 0x1E08F, 0x1E2AE, 0x1E6E3, 0x1E6E6, 0x1E6F5, 0x1E6FF, 0xE0001); +set.addRange(0xB7, 0xB8).addRange(0x2B0, 0x36F).addRange(0x374, 0x375).addRange(0x384, 0x385).addRange(0x483, 0x489).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x600, 0x605).addRange(0x610, 0x61A).addRange(0x64B, 0x65F).addRange(0x6D6, 0x6DD).addRange(0x6DF, 0x6E8).addRange(0x6EA, 0x6ED).addRange(0x730, 0x74A).addRange(0x7A6, 0x7B0).addRange(0x7EB, 0x7F5).addRange(0x816, 0x82D).addRange(0x859, 0x85B).addRange(0x890, 0x891).addRange(0x897, 0x89F).addRange(0x8C9, 0x902).addRange(0x941, 0x948).addRange(0x951, 0x957).addRange(0x962, 0x963).addRange(0x9C1, 0x9C4).addRange(0x9E2, 0x9E3).addRange(0xA01, 0xA02).addRange(0xA41, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA70, 0xA71).addRange(0xA81, 0xA82).addRange(0xAC1, 0xAC5).addRange(0xAC7, 0xAC8).addRange(0xAE2, 0xAE3).addRange(0xAFA, 0xAFF).addRange(0xB41, 0xB44).addRange(0xB55, 0xB56).addRange(0xB62, 0xB63).addRange(0xC3E, 0xC40).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC62, 0xC63).addRange(0xCCC, 0xCCD).addRange(0xCE2, 0xCE3).addRange(0xD00, 0xD01).addRange(0xD3B, 0xD3C).addRange(0xD41, 0xD44).addRange(0xD62, 0xD63); +set.addRange(0xDD2, 0xDD4).addRange(0xE34, 0xE3A).addRange(0xE46, 0xE4E).addRange(0xEB4, 0xEBC).addRange(0xEC8, 0xECE).addRange(0xF18, 0xF19).addRange(0xF71, 0xF7E).addRange(0xF80, 0xF84).addRange(0xF86, 0xF87).addRange(0xF8D, 0xF97).addRange(0xF99, 0xFBC).addRange(0x102D, 0x1030).addRange(0x1032, 0x1037).addRange(0x1039, 0x103A).addRange(0x103D, 0x103E).addRange(0x1058, 0x1059).addRange(0x105E, 0x1060).addRange(0x1071, 0x1074).addRange(0x1085, 0x1086).addRange(0x135D, 0x135F).addRange(0x1712, 0x1714).addRange(0x1732, 0x1733).addRange(0x1752, 0x1753).addRange(0x1772, 0x1773).addRange(0x17B4, 0x17B5).addRange(0x17B7, 0x17BD).addRange(0x17C9, 0x17D3).addRange(0x180B, 0x180F).addRange(0x1885, 0x1886).addRange(0x1920, 0x1922).addRange(0x1927, 0x1928).addRange(0x1939, 0x193B).addRange(0x1A17, 0x1A18).addRange(0x1A58, 0x1A5E).addRange(0x1A65, 0x1A6C).addRange(0x1A73, 0x1A7C).addRange(0x1AB0, 0x1ADD).addRange(0x1AE0, 0x1AEB).addRange(0x1B00, 0x1B03).addRange(0x1B36, 0x1B3A).addRange(0x1B6B, 0x1B73).addRange(0x1B80, 0x1B81).addRange(0x1BA2, 0x1BA5).addRange(0x1BA8, 0x1BA9).addRange(0x1BAB, 0x1BAD).addRange(0x1BE8, 0x1BE9).addRange(0x1BEF, 0x1BF1).addRange(0x1C2C, 0x1C33).addRange(0x1C36, 0x1C37).addRange(0x1C78, 0x1C7D).addRange(0x1CD0, 0x1CD2); +set.addRange(0x1CD4, 0x1CE0).addRange(0x1CE2, 0x1CE8).addRange(0x1CF8, 0x1CF9).addRange(0x1D2C, 0x1D6A).addRange(0x1D9B, 0x1DFF).addRange(0x1FBF, 0x1FC1).addRange(0x1FCD, 0x1FCF).addRange(0x1FDD, 0x1FDF).addRange(0x1FED, 0x1FEF).addRange(0x1FFD, 0x1FFE).addRange(0x200B, 0x200F).addRange(0x2018, 0x2019).addRange(0x202A, 0x202E).addRange(0x2060, 0x2064).addRange(0x2066, 0x206F).addRange(0x2090, 0x209C).addRange(0x20D0, 0x20F0).addRange(0x2C7C, 0x2C7D).addRange(0x2CEF, 0x2CF1).addRange(0x2DE0, 0x2DFF).addRange(0x302A, 0x302D).addRange(0x3031, 0x3035).addRange(0x3099, 0x309E).addRange(0x30FC, 0x30FE).addRange(0xA4F8, 0xA4FD).addRange(0xA66F, 0xA672).addRange(0xA674, 0xA67D).addRange(0xA69C, 0xA69F).addRange(0xA6F0, 0xA6F1).addRange(0xA700, 0xA721).addRange(0xA788, 0xA78A).addRange(0xA7F1, 0xA7F4).addRange(0xA7F8, 0xA7F9).addRange(0xA825, 0xA826).addRange(0xA8C4, 0xA8C5).addRange(0xA8E0, 0xA8F1).addRange(0xA926, 0xA92D).addRange(0xA947, 0xA951).addRange(0xA980, 0xA982).addRange(0xA9B6, 0xA9B9).addRange(0xA9BC, 0xA9BD).addRange(0xA9E5, 0xA9E6).addRange(0xAA29, 0xAA2E).addRange(0xAA31, 0xAA32).addRange(0xAA35, 0xAA36).addRange(0xAAB2, 0xAAB4).addRange(0xAAB7, 0xAAB8).addRange(0xAABE, 0xAABF).addRange(0xAAEC, 0xAAED).addRange(0xAAF3, 0xAAF4).addRange(0xAB5B, 0xAB5F); +set.addRange(0xAB69, 0xAB6B).addRange(0xFBB2, 0xFBC2).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2F).addRange(0xFF9E, 0xFF9F).addRange(0xFFF9, 0xFFFB).addRange(0x10376, 0x1037A).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10A01, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A0F).addRange(0x10A38, 0x10A3A).addRange(0x10AE5, 0x10AE6).addRange(0x10D24, 0x10D27).addRange(0x10D69, 0x10D6D).addRange(0x10EAB, 0x10EAC).addRange(0x10EFA, 0x10EFF).addRange(0x10F46, 0x10F50).addRange(0x10F82, 0x10F85).addRange(0x11038, 0x11046).addRange(0x11073, 0x11074).addRange(0x1107F, 0x11081).addRange(0x110B3, 0x110B6).addRange(0x110B9, 0x110BA).addRange(0x11100, 0x11102).addRange(0x11127, 0x1112B).addRange(0x1112D, 0x11134).addRange(0x11180, 0x11181).addRange(0x111B6, 0x111BE).addRange(0x111C9, 0x111CC).addRange(0x1122F, 0x11231).addRange(0x11236, 0x11237).addRange(0x112E3, 0x112EA).addRange(0x11300, 0x11301).addRange(0x1133B, 0x1133C).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x113BB, 0x113C0).addRange(0x113E1, 0x113E2).addRange(0x11438, 0x1143F).addRange(0x11442, 0x11444).addRange(0x114B3, 0x114B8).addRange(0x114BF, 0x114C0).addRange(0x114C2, 0x114C3).addRange(0x115B2, 0x115B5).addRange(0x115BC, 0x115BD).addRange(0x115BF, 0x115C0).addRange(0x115DC, 0x115DD).addRange(0x11633, 0x1163A); +set.addRange(0x1163F, 0x11640).addRange(0x116B0, 0x116B5).addRange(0x11722, 0x11725).addRange(0x11727, 0x1172B).addRange(0x1182F, 0x11837).addRange(0x11839, 0x1183A).addRange(0x1193B, 0x1193C).addRange(0x119D4, 0x119D7).addRange(0x119DA, 0x119DB).addRange(0x11A01, 0x11A0A).addRange(0x11A33, 0x11A38).addRange(0x11A3B, 0x11A3E).addRange(0x11A51, 0x11A56).addRange(0x11A59, 0x11A5B).addRange(0x11A8A, 0x11A96).addRange(0x11A98, 0x11A99).addRange(0x11B62, 0x11B64).addRange(0x11C30, 0x11C36).addRange(0x11C38, 0x11C3D).addRange(0x11C92, 0x11CA7).addRange(0x11CAA, 0x11CB0).addRange(0x11CB2, 0x11CB3).addRange(0x11CB5, 0x11CB6).addRange(0x11D31, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D45).addRange(0x11D90, 0x11D91).addRange(0x11EF3, 0x11EF4).addRange(0x11F00, 0x11F01).addRange(0x11F36, 0x11F3A).addRange(0x13430, 0x13440).addRange(0x13447, 0x13455).addRange(0x1611E, 0x16129).addRange(0x1612D, 0x1612F).addRange(0x16AF0, 0x16AF4).addRange(0x16B30, 0x16B36).addRange(0x16B40, 0x16B43).addRange(0x16D40, 0x16D42).addRange(0x16D6B, 0x16D6C).addRange(0x16F8F, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x16FE3, 0x16FE4).addRange(0x16FF2, 0x16FF3).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1BC9D, 0x1BC9E).addRange(0x1BCA0, 0x1BCA3).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D167, 0x1D169); +set.addRange(0x1D173, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1D242, 0x1D244).addRange(0x1DA00, 0x1DA36).addRange(0x1DA3B, 0x1DA6C).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E030, 0x1E06D).addRange(0x1E130, 0x1E13D).addRange(0x1E2EC, 0x1E2EF).addRange(0x1E4EB, 0x1E4EF).addRange(0x1E5EE, 0x1E5EF).addRange(0x1E6EE, 0x1E6EF).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E944, 0x1E94B).addRange(0x1F3FB, 0x1F3FF).addRange(0xE0020, 0xE007F).addRange(0xE0100, 0xE01EF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Cased.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Cased.js new file mode 100644 index 0000000000000000000000000000000000000000..a5b4ef08866e211845206c248a931117a808a6aa --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Cased.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0xAA, 0xB5, 0xBA, 0x345, 0x37F, 0x386, 0x38C, 0x10C7, 0x10CD, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2071, 0x207F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2139, 0x214E, 0x2D27, 0x2D2D, 0x10780, 0x1D4A2, 0x1D4BB, 0x1D546); +set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x1BA).addRange(0x1BC, 0x1BF).addRange(0x1C4, 0x293).addRange(0x296, 0x2B8).addRange(0x2C0, 0x2C1).addRange(0x2E0, 0x2E4).addRange(0x370, 0x373).addRange(0x376, 0x377).addRange(0x37A, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x10FF).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1D00, 0x1DBF).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x2090, 0x209C).addRange(0x210A, 0x2113).addRange(0x2119, 0x211D).addRange(0x212A, 0x212D).addRange(0x212F, 0x2134).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149); +set.addRange(0x2160, 0x217F).addRange(0x2183, 0x2184).addRange(0x24B6, 0x24E9).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0xA640, 0xA66D).addRange(0xA680, 0xA69D).addRange(0xA722, 0xA787).addRange(0xA78B, 0xA78E).addRange(0xA790, 0xA7DC).addRange(0xA7F1, 0xA7F6).addRange(0xA7F8, 0xA7FA).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0x10400, 0x1044F).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10783, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D50, 0x10D65).addRange(0x10D70, 0x10D85).addRange(0x118A0, 0x118DF).addRange(0x16E40, 0x16E7F).addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505); +set.addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1DF00, 0x1DF09).addRange(0x1DF0B, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E030, 0x1E06D).addRange(0x1E900, 0x1E943).addRange(0x1F130, 0x1F149).addRange(0x1F150, 0x1F169).addRange(0x1F170, 0x1F189); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Casefolded.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Casefolded.js new file mode 100644 index 0000000000000000000000000000000000000000..fdc5c5a3b60ea4727295a2235a0ef0bcb9844528 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Casefolded.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0xB5, 0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x17B, 0x17D, 0x17F, 0x184, 0x1A2, 0x1A4, 0x1A9, 0x1AC, 0x1B5, 0x1BC, 0x1CD, 0x1CF, 0x1D1, 0x1D3, 0x1D5, 0x1D7, 0x1D9, 0x1DB, 0x1DE, 0x1E0, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x1EA, 0x1EC, 0x1EE, 0x1F4, 0x1FA, 0x1FC, 0x1FE, 0x200, 0x202, 0x204, 0x206, 0x208, 0x20A, 0x20C, 0x20E, 0x210, 0x212, 0x214, 0x216, 0x218, 0x21A, 0x21C, 0x21E, 0x220, 0x222, 0x224, 0x226, 0x228, 0x22A, 0x22C, 0x22E, 0x230, 0x232, 0x241, 0x248, 0x24A, 0x24C, 0x24E, 0x345, 0x370, 0x372, 0x376, 0x37F, 0x386, 0x38C, 0x3C2, 0x3D8, 0x3DA, 0x3DC, 0x3DE, 0x3E0, 0x3E2, 0x3E4, 0x3E6, 0x3E8, 0x3EA, 0x3EC, 0x3EE, 0x3F7, 0x460, 0x462, 0x464, 0x466, 0x468, 0x46A, 0x46C, 0x46E, 0x470, 0x472, 0x474, 0x476, 0x478, 0x47A, 0x47C, 0x47E, 0x480, 0x48A, 0x48C, 0x48E, 0x490, 0x492, 0x494, 0x496, 0x498, 0x49A, 0x49C, 0x49E, 0x4A0, 0x4A2, 0x4A4, 0x4A6, 0x4A8, 0x4AA, 0x4AC, 0x4AE, 0x4B0, 0x4B2, 0x4B4, 0x4B6, 0x4B8, 0x4BA, 0x4BC, 0x4BE, 0x4C3, 0x4C5, 0x4C7, 0x4C9, 0x4CB, 0x4CD, 0x4D0, 0x4D2, 0x4D4, 0x4D6, 0x4D8, 0x4DA, 0x4DC, 0x4DE, 0x4E0, 0x4E2, 0x4E4, 0x4E6, 0x4E8, 0x4EA, 0x4EC, 0x4EE, 0x4F0, 0x4F2, 0x4F4, 0x4F6, 0x4F8, 0x4FA, 0x4FC, 0x4FE, 0x500, 0x502, 0x504, 0x506, 0x508, 0x50A, 0x50C, 0x50E, 0x510, 0x512, 0x514, 0x516, 0x518, 0x51A, 0x51C, 0x51E, 0x520, 0x522, 0x524, 0x526, 0x528, 0x52A, 0x52C, 0x52E, 0x587, 0x10C7, 0x10CD, 0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12, 0x1E14, 0x1E16, 0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26, 0x1E28, 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, 0x1E3A, 0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C, 0x1E4E, 0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62, 0x1E64, 0x1E66, 0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76, 0x1E78, 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, 0x1E8A, 0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94, 0x1E9E, 0x1EA0, 0x1EA2, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4, 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4, 0x1EF6, 0x1EF8, 0x1EFA, 0x1EFC, 0x1EFE, 0x1F59, 0x1F5B, 0x1F5D, 0x1F5F, 0x2126, 0x2132, 0x2183, 0x2C60, 0x2C67, 0x2C69, 0x2C6B, 0x2C72, 0x2C75, 0x2C82, 0x2C84, 0x2C86, 0x2C88, 0x2C8A, 0x2C8C, 0x2C8E, 0x2C90, 0x2C92, 0x2C94, 0x2C96, 0x2C98, 0x2C9A, 0x2C9C, 0x2C9E, 0x2CA0, 0x2CA2, 0x2CA4, 0x2CA6, 0x2CA8, 0x2CAA, 0x2CAC, 0x2CAE, 0x2CB0, 0x2CB2, 0x2CB4, 0x2CB6, 0x2CB8, 0x2CBA, 0x2CBC, 0x2CBE, 0x2CC0, 0x2CC2, 0x2CC4, 0x2CC6, 0x2CC8, 0x2CCA, 0x2CCC, 0x2CCE, 0x2CD0, 0x2CD2, 0x2CD4, 0x2CD6, 0x2CD8, 0x2CDA, 0x2CDC, 0x2CDE, 0x2CE0, 0x2CE2, 0x2CEB, 0x2CED, 0x2CF2, 0xA640, 0xA642, 0xA644, 0xA646, 0xA648, 0xA64A, 0xA64C, 0xA64E, 0xA650, 0xA652, 0xA654, 0xA656, 0xA658, 0xA65A, 0xA65C, 0xA65E, 0xA660, 0xA662, 0xA664, 0xA666, 0xA668, 0xA66A, 0xA66C, 0xA680, 0xA682, 0xA684, 0xA686, 0xA688, 0xA68A, 0xA68C, 0xA68E, 0xA690, 0xA692, 0xA694, 0xA696, 0xA698, 0xA69A, 0xA722, 0xA724, 0xA726, 0xA728, 0xA72A, 0xA72C, 0xA72E, 0xA732, 0xA734, 0xA736, 0xA738, 0xA73A, 0xA73C, 0xA73E, 0xA740, 0xA742, 0xA744, 0xA746, 0xA748, 0xA74A, 0xA74C, 0xA74E, 0xA750, 0xA752, 0xA754, 0xA756, 0xA758, 0xA75A, 0xA75C, 0xA75E, 0xA760, 0xA762, 0xA764, 0xA766, 0xA768, 0xA76A, 0xA76C, 0xA76E, 0xA779, 0xA77B, 0xA780, 0xA782, 0xA784, 0xA786, 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798, 0xA79A, 0xA79C, 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7B6, 0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C9, 0xA7CE, 0xA7D0, 0xA7D2, 0xA7D4, 0xA7D6, 0xA7D8, 0xA7DA, 0xA7DC, 0xA7F5); +set.addRange(0x41, 0x5A).addRange(0xC0, 0xD6).addRange(0xD8, 0xDF).addRange(0x149, 0x14A).addRange(0x178, 0x179).addRange(0x181, 0x182).addRange(0x186, 0x187).addRange(0x189, 0x18B).addRange(0x18E, 0x191).addRange(0x193, 0x194).addRange(0x196, 0x198).addRange(0x19C, 0x19D).addRange(0x19F, 0x1A0).addRange(0x1A6, 0x1A7).addRange(0x1AE, 0x1AF).addRange(0x1B1, 0x1B3).addRange(0x1B7, 0x1B8).addRange(0x1C4, 0x1C5).addRange(0x1C7, 0x1C8).addRange(0x1CA, 0x1CB).addRange(0x1F1, 0x1F2).addRange(0x1F6, 0x1F8).addRange(0x23A, 0x23B).addRange(0x23D, 0x23E).addRange(0x243, 0x246).addRange(0x388, 0x38A).addRange(0x38E, 0x38F).addRange(0x391, 0x3A1).addRange(0x3A3, 0x3AB).addRange(0x3CF, 0x3D1).addRange(0x3D5, 0x3D6).addRange(0x3F0, 0x3F1).addRange(0x3F4, 0x3F5).addRange(0x3F9, 0x3FA).addRange(0x3FD, 0x42F).addRange(0x4C0, 0x4C1).addRange(0x531, 0x556).addRange(0x10A0, 0x10C5).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C89).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1E9A, 0x1E9B).addRange(0x1F08, 0x1F0F).addRange(0x1F18, 0x1F1D).addRange(0x1F28, 0x1F2F).addRange(0x1F38, 0x1F3F).addRange(0x1F48, 0x1F4D).addRange(0x1F68, 0x1F6F).addRange(0x1F80, 0x1FAF).addRange(0x1FB2, 0x1FB4); +set.addRange(0x1FB7, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC7, 0x1FCC).addRange(0x1FD8, 0x1FDB).addRange(0x1FE8, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF7, 0x1FFC).addRange(0x212A, 0x212B).addRange(0x2160, 0x216F).addRange(0x24B6, 0x24CF).addRange(0x2C00, 0x2C2F).addRange(0x2C62, 0x2C64).addRange(0x2C6D, 0x2C70).addRange(0x2C7E, 0x2C80).addRange(0xA77D, 0xA77E).addRange(0xA7AA, 0xA7AE).addRange(0xA7B0, 0xA7B4).addRange(0xA7C4, 0xA7C7).addRange(0xA7CB, 0xA7CC).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF21, 0xFF3A).addRange(0x10400, 0x10427).addRange(0x104B0, 0x104D3).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10C80, 0x10CB2).addRange(0x10D50, 0x10D65).addRange(0x118A0, 0x118BF).addRange(0x16E40, 0x16E5F).addRange(0x16EA0, 0x16EB8).addRange(0x1E900, 0x1E921); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Casemapped.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Casemapped.js new file mode 100644 index 0000000000000000000000000000000000000000..bcf0f9cb538375e2d305628a010bcd9776cfd825 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Casemapped.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0xB5, 0x1BF, 0x259, 0x26F, 0x275, 0x27D, 0x280, 0x292, 0x345, 0x37F, 0x386, 0x38C, 0x10C7, 0x10CD, 0x1D79, 0x1D7D, 0x1D8E, 0x1E9E, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2126, 0x2132, 0x214E, 0x2D27, 0x2D2D, 0xAB53); +set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x137).addRange(0x139, 0x18C).addRange(0x18E, 0x1A9).addRange(0x1AC, 0x1B9).addRange(0x1BC, 0x1BD).addRange(0x1C4, 0x220).addRange(0x222, 0x233).addRange(0x23A, 0x254).addRange(0x256, 0x257).addRange(0x25B, 0x25C).addRange(0x260, 0x261).addRange(0x263, 0x266).addRange(0x268, 0x26C).addRange(0x271, 0x272).addRange(0x282, 0x283).addRange(0x287, 0x28C).addRange(0x29D, 0x29E).addRange(0x370, 0x373).addRange(0x376, 0x377).addRange(0x37B, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3D1).addRange(0x3D5, 0x3F5).addRange(0x3F7, 0x3FB).addRange(0x3FD, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x561, 0x587).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FD, 0x10FF).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1E00, 0x1E9B).addRange(0x1EA0, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4); +set.addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x212A, 0x212B).addRange(0x2160, 0x217F).addRange(0x2183, 0x2184).addRange(0x24B6, 0x24E9).addRange(0x2C00, 0x2C70).addRange(0x2C72, 0x2C73).addRange(0x2C75, 0x2C76).addRange(0x2C7E, 0x2CE3).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0xA640, 0xA66D).addRange(0xA680, 0xA69B).addRange(0xA722, 0xA72F).addRange(0xA732, 0xA76F).addRange(0xA779, 0xA787).addRange(0xA78B, 0xA78D).addRange(0xA790, 0xA794).addRange(0xA796, 0xA7AE).addRange(0xA7B0, 0xA7DC).addRange(0xA7F5, 0xA7F6).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0x10400, 0x1044F).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D50, 0x10D65).addRange(0x10D70, 0x10D85).addRange(0x118A0, 0x118DF).addRange(0x16E40, 0x16E7F).addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3); +set.addRange(0x1E900, 0x1E943); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Lowercased.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Lowercased.js new file mode 100644 index 0000000000000000000000000000000000000000..377ddf145992a4f4393063eb75d996618e928b1a --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Lowercased.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14A, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x17B, 0x17D, 0x184, 0x1A2, 0x1A4, 0x1A9, 0x1AC, 0x1B5, 0x1BC, 0x1CD, 0x1CF, 0x1D1, 0x1D3, 0x1D5, 0x1D7, 0x1D9, 0x1DB, 0x1DE, 0x1E0, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x1EA, 0x1EC, 0x1EE, 0x1F4, 0x1FA, 0x1FC, 0x1FE, 0x200, 0x202, 0x204, 0x206, 0x208, 0x20A, 0x20C, 0x20E, 0x210, 0x212, 0x214, 0x216, 0x218, 0x21A, 0x21C, 0x21E, 0x220, 0x222, 0x224, 0x226, 0x228, 0x22A, 0x22C, 0x22E, 0x230, 0x232, 0x241, 0x248, 0x24A, 0x24C, 0x24E, 0x370, 0x372, 0x376, 0x37F, 0x386, 0x38C, 0x3CF, 0x3D8, 0x3DA, 0x3DC, 0x3DE, 0x3E0, 0x3E2, 0x3E4, 0x3E6, 0x3E8, 0x3EA, 0x3EC, 0x3EE, 0x3F4, 0x3F7, 0x460, 0x462, 0x464, 0x466, 0x468, 0x46A, 0x46C, 0x46E, 0x470, 0x472, 0x474, 0x476, 0x478, 0x47A, 0x47C, 0x47E, 0x480, 0x48A, 0x48C, 0x48E, 0x490, 0x492, 0x494, 0x496, 0x498, 0x49A, 0x49C, 0x49E, 0x4A0, 0x4A2, 0x4A4, 0x4A6, 0x4A8, 0x4AA, 0x4AC, 0x4AE, 0x4B0, 0x4B2, 0x4B4, 0x4B6, 0x4B8, 0x4BA, 0x4BC, 0x4BE, 0x4C3, 0x4C5, 0x4C7, 0x4C9, 0x4CB, 0x4CD, 0x4D0, 0x4D2, 0x4D4, 0x4D6, 0x4D8, 0x4DA, 0x4DC, 0x4DE, 0x4E0, 0x4E2, 0x4E4, 0x4E6, 0x4E8, 0x4EA, 0x4EC, 0x4EE, 0x4F0, 0x4F2, 0x4F4, 0x4F6, 0x4F8, 0x4FA, 0x4FC, 0x4FE, 0x500, 0x502, 0x504, 0x506, 0x508, 0x50A, 0x50C, 0x50E, 0x510, 0x512, 0x514, 0x516, 0x518, 0x51A, 0x51C, 0x51E, 0x520, 0x522, 0x524, 0x526, 0x528, 0x52A, 0x52C, 0x52E, 0x10C7, 0x10CD, 0x1C89, 0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12, 0x1E14, 0x1E16, 0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26, 0x1E28, 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, 0x1E3A, 0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C, 0x1E4E, 0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62, 0x1E64, 0x1E66, 0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76, 0x1E78, 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, 0x1E8A, 0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94, 0x1E9E, 0x1EA0, 0x1EA2, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4, 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4, 0x1EF6, 0x1EF8, 0x1EFA, 0x1EFC, 0x1EFE, 0x1F59, 0x1F5B, 0x1F5D, 0x1F5F, 0x2126, 0x2132, 0x2183, 0x2C60, 0x2C67, 0x2C69, 0x2C6B, 0x2C72, 0x2C75, 0x2C82, 0x2C84, 0x2C86, 0x2C88, 0x2C8A, 0x2C8C, 0x2C8E, 0x2C90, 0x2C92, 0x2C94, 0x2C96, 0x2C98, 0x2C9A, 0x2C9C, 0x2C9E, 0x2CA0, 0x2CA2, 0x2CA4, 0x2CA6, 0x2CA8, 0x2CAA, 0x2CAC, 0x2CAE, 0x2CB0, 0x2CB2, 0x2CB4, 0x2CB6, 0x2CB8, 0x2CBA, 0x2CBC, 0x2CBE, 0x2CC0, 0x2CC2, 0x2CC4, 0x2CC6, 0x2CC8, 0x2CCA, 0x2CCC, 0x2CCE, 0x2CD0, 0x2CD2, 0x2CD4, 0x2CD6, 0x2CD8, 0x2CDA, 0x2CDC, 0x2CDE, 0x2CE0, 0x2CE2, 0x2CEB, 0x2CED, 0x2CF2, 0xA640, 0xA642, 0xA644, 0xA646, 0xA648, 0xA64A, 0xA64C, 0xA64E, 0xA650, 0xA652, 0xA654, 0xA656, 0xA658, 0xA65A, 0xA65C, 0xA65E, 0xA660, 0xA662, 0xA664, 0xA666, 0xA668, 0xA66A, 0xA66C, 0xA680, 0xA682, 0xA684, 0xA686, 0xA688, 0xA68A, 0xA68C, 0xA68E, 0xA690, 0xA692, 0xA694, 0xA696, 0xA698, 0xA69A, 0xA722, 0xA724, 0xA726, 0xA728, 0xA72A, 0xA72C, 0xA72E, 0xA732, 0xA734, 0xA736, 0xA738, 0xA73A, 0xA73C, 0xA73E, 0xA740, 0xA742, 0xA744, 0xA746, 0xA748, 0xA74A, 0xA74C, 0xA74E, 0xA750, 0xA752, 0xA754, 0xA756, 0xA758, 0xA75A, 0xA75C, 0xA75E, 0xA760, 0xA762, 0xA764, 0xA766, 0xA768, 0xA76A, 0xA76C, 0xA76E, 0xA779, 0xA77B, 0xA780, 0xA782, 0xA784, 0xA786, 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798, 0xA79A, 0xA79C, 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7B6, 0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C9, 0xA7CE, 0xA7D0, 0xA7D2, 0xA7D4, 0xA7D6, 0xA7D8, 0xA7DA, 0xA7DC, 0xA7F5); +set.addRange(0x41, 0x5A).addRange(0xC0, 0xD6).addRange(0xD8, 0xDE).addRange(0x178, 0x179).addRange(0x181, 0x182).addRange(0x186, 0x187).addRange(0x189, 0x18B).addRange(0x18E, 0x191).addRange(0x193, 0x194).addRange(0x196, 0x198).addRange(0x19C, 0x19D).addRange(0x19F, 0x1A0).addRange(0x1A6, 0x1A7).addRange(0x1AE, 0x1AF).addRange(0x1B1, 0x1B3).addRange(0x1B7, 0x1B8).addRange(0x1C4, 0x1C5).addRange(0x1C7, 0x1C8).addRange(0x1CA, 0x1CB).addRange(0x1F1, 0x1F2).addRange(0x1F6, 0x1F8).addRange(0x23A, 0x23B).addRange(0x23D, 0x23E).addRange(0x243, 0x246).addRange(0x388, 0x38A).addRange(0x38E, 0x38F).addRange(0x391, 0x3A1).addRange(0x3A3, 0x3AB).addRange(0x3F9, 0x3FA).addRange(0x3FD, 0x42F).addRange(0x4C0, 0x4C1).addRange(0x531, 0x556).addRange(0x10A0, 0x10C5).addRange(0x13A0, 0x13F5).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1F08, 0x1F0F).addRange(0x1F18, 0x1F1D).addRange(0x1F28, 0x1F2F).addRange(0x1F38, 0x1F3F).addRange(0x1F48, 0x1F4D).addRange(0x1F68, 0x1F6F).addRange(0x1F88, 0x1F8F).addRange(0x1F98, 0x1F9F).addRange(0x1FA8, 0x1FAF).addRange(0x1FB8, 0x1FBC).addRange(0x1FC8, 0x1FCC).addRange(0x1FD8, 0x1FDB).addRange(0x1FE8, 0x1FEC).addRange(0x1FF8, 0x1FFC).addRange(0x212A, 0x212B); +set.addRange(0x2160, 0x216F).addRange(0x24B6, 0x24CF).addRange(0x2C00, 0x2C2F).addRange(0x2C62, 0x2C64).addRange(0x2C6D, 0x2C70).addRange(0x2C7E, 0x2C80).addRange(0xA77D, 0xA77E).addRange(0xA7AA, 0xA7AE).addRange(0xA7B0, 0xA7B4).addRange(0xA7C4, 0xA7C7).addRange(0xA7CB, 0xA7CC).addRange(0xFF21, 0xFF3A).addRange(0x10400, 0x10427).addRange(0x104B0, 0x104D3).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10C80, 0x10CB2).addRange(0x10D50, 0x10D65).addRange(0x118A0, 0x118BF).addRange(0x16E40, 0x16E5F).addRange(0x16EA0, 0x16EB8).addRange(0x1E900, 0x1E921); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_NFKC_Casefolded.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_NFKC_Casefolded.js new file mode 100644 index 0000000000000000000000000000000000000000..873d0a35829ce7f63cc9467c583e5a0fe28b4d91 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_NFKC_Casefolded.js @@ -0,0 +1,7 @@ +const set = require('regenerate')(0xA0, 0xA8, 0xAA, 0xAD, 0xAF, 0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x136, 0x139, 0x13B, 0x13D, 0x143, 0x145, 0x147, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x17B, 0x17D, 0x17F, 0x184, 0x1A2, 0x1A4, 0x1A9, 0x1AC, 0x1B5, 0x1BC, 0x1CF, 0x1D1, 0x1D3, 0x1D5, 0x1D7, 0x1D9, 0x1DB, 0x1DE, 0x1E0, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x1EA, 0x1EC, 0x1EE, 0x1FA, 0x1FC, 0x1FE, 0x200, 0x202, 0x204, 0x206, 0x208, 0x20A, 0x20C, 0x20E, 0x210, 0x212, 0x214, 0x216, 0x218, 0x21A, 0x21C, 0x21E, 0x220, 0x222, 0x224, 0x226, 0x228, 0x22A, 0x22C, 0x22E, 0x230, 0x232, 0x241, 0x248, 0x24A, 0x24C, 0x24E, 0x34F, 0x370, 0x372, 0x374, 0x376, 0x37A, 0x38C, 0x3C2, 0x3D8, 0x3DA, 0x3DC, 0x3DE, 0x3E0, 0x3E2, 0x3E4, 0x3E6, 0x3E8, 0x3EA, 0x3EC, 0x3EE, 0x3F7, 0x460, 0x462, 0x464, 0x466, 0x468, 0x46A, 0x46C, 0x46E, 0x470, 0x472, 0x474, 0x476, 0x478, 0x47A, 0x47C, 0x47E, 0x480, 0x48A, 0x48C, 0x48E, 0x490, 0x492, 0x494, 0x496, 0x498, 0x49A, 0x49C, 0x49E, 0x4A0, 0x4A2, 0x4A4, 0x4A6, 0x4A8, 0x4AA, 0x4AC, 0x4AE, 0x4B0, 0x4B2, 0x4B4, 0x4B6, 0x4B8, 0x4BA, 0x4BC, 0x4BE, 0x4C3, 0x4C5, 0x4C7, 0x4C9, 0x4CB, 0x4CD, 0x4D0, 0x4D2, 0x4D4, 0x4D6, 0x4D8, 0x4DA, 0x4DC, 0x4DE, 0x4E0, 0x4E2, 0x4E4, 0x4E6, 0x4E8, 0x4EA, 0x4EC, 0x4EE, 0x4F0, 0x4F2, 0x4F4, 0x4F6, 0x4F8, 0x4FA, 0x4FC, 0x4FE, 0x500, 0x502, 0x504, 0x506, 0x508, 0x50A, 0x50C, 0x50E, 0x510, 0x512, 0x514, 0x516, 0x518, 0x51A, 0x51C, 0x51E, 0x520, 0x522, 0x524, 0x526, 0x528, 0x52A, 0x52C, 0x52E, 0x587, 0x61C, 0x9DF, 0xA33, 0xA36, 0xA5E, 0xE33, 0xEB3, 0xF0C, 0xF43, 0xF4D, 0xF52, 0xF57, 0xF5C, 0xF69, 0xF73, 0xF81, 0xF93, 0xF9D, 0xFA2, 0xFA7, 0xFAC, 0xFB9, 0x10C7, 0x10CD, 0x10FC, 0x1D78, 0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12, 0x1E14, 0x1E16, 0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26, 0x1E28, 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, 0x1E3A, 0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C, 0x1E4E, 0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62, 0x1E64, 0x1E66, 0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76, 0x1E78, 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, 0x1E8A, 0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94, 0x1E9E, 0x1EA0, 0x1EA2, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4, 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4, 0x1EF6, 0x1EF8, 0x1EFA, 0x1EFC, 0x1EFE, 0x1F59, 0x1F5B, 0x1F5D, 0x1F5F, 0x1F71, 0x1F73, 0x1F75, 0x1F77, 0x1F79, 0x1F7B, 0x1F7D, 0x1FD3, 0x1FE3, 0x2011, 0x2017, 0x203C, 0x203E, 0x2057, 0x20A8, 0x2124, 0x2126, 0x2128, 0x2183, 0x2189, 0x2A0C, 0x2ADC, 0x2C60, 0x2C67, 0x2C69, 0x2C6B, 0x2C72, 0x2C75, 0x2C82, 0x2C84, 0x2C86, 0x2C88, 0x2C8A, 0x2C8C, 0x2C8E, 0x2C90, 0x2C92, 0x2C94, 0x2C96, 0x2C98, 0x2C9A, 0x2C9C, 0x2C9E, 0x2CA0, 0x2CA2, 0x2CA4, 0x2CA6, 0x2CA8, 0x2CAA, 0x2CAC, 0x2CAE, 0x2CB0, 0x2CB2, 0x2CB4, 0x2CB6, 0x2CB8, 0x2CBA, 0x2CBC, 0x2CBE, 0x2CC0, 0x2CC2, 0x2CC4, 0x2CC6, 0x2CC8, 0x2CCA, 0x2CCC, 0x2CCE, 0x2CD0, 0x2CD2, 0x2CD4, 0x2CD6, 0x2CD8, 0x2CDA, 0x2CDC, 0x2CDE, 0x2CE0, 0x2CE2, 0x2CEB, 0x2CED, 0x2CF2, 0x2D6F, 0x2E9F, 0x2EF3, 0x3000, 0x3036, 0x309F, 0x30FF, 0xA640, 0xA642, 0xA644, 0xA646, 0xA648, 0xA64A, 0xA64C, 0xA64E, 0xA650, 0xA652, 0xA654, 0xA656, 0xA658, 0xA65A, 0xA65C, 0xA65E, 0xA660, 0xA662, 0xA664, 0xA666, 0xA668, 0xA66A, 0xA66C, 0xA680, 0xA682, 0xA684, 0xA686, 0xA688, 0xA68A, 0xA68C, 0xA68E, 0xA690, 0xA692, 0xA694, 0xA696, 0xA698, 0xA69A, 0xA722, 0xA724, 0xA726, 0xA728, 0xA72A, 0xA72C, 0xA72E, 0xA732, 0xA734, 0xA736, 0xA738, 0xA73A, 0xA73C, 0xA73E, 0xA740, 0xA742, 0xA744, 0xA746, 0xA748, 0xA74A, 0xA74C, 0xA74E, 0xA750, 0xA752, 0xA754, 0xA756, 0xA758, 0xA75A, 0xA75C, 0xA75E, 0xA760, 0xA762, 0xA764, 0xA766, 0xA768, 0xA76A, 0xA76C, 0xA76E, 0xA770, 0xA779, 0xA77B, 0xA780, 0xA782, 0xA784, 0xA786, 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798, 0xA79A, 0xA79C, 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7B6, 0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C9, 0xA7CE, 0xA7D0, 0xA7D2, 0xA7D4, 0xA7D6, 0xA7D8, 0xA7DA, 0xA7DC, 0xAB69, 0xFA10, 0xFA12, 0xFA20, 0xFA22, 0xFB1D, 0xFB3E, 0xFE74, 0xFEFF, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E, 0x1F190); +set.addRange(0x41, 0x5A).addRange(0xB2, 0xB5).addRange(0xB8, 0xBA).addRange(0xBC, 0xBE).addRange(0xC0, 0xD6).addRange(0xD8, 0xDF).addRange(0x132, 0x134).addRange(0x13F, 0x141).addRange(0x149, 0x14A).addRange(0x178, 0x179).addRange(0x181, 0x182).addRange(0x186, 0x187).addRange(0x189, 0x18B).addRange(0x18E, 0x191).addRange(0x193, 0x194).addRange(0x196, 0x198).addRange(0x19C, 0x19D).addRange(0x19F, 0x1A0).addRange(0x1A6, 0x1A7).addRange(0x1AE, 0x1AF).addRange(0x1B1, 0x1B3).addRange(0x1B7, 0x1B8).addRange(0x1C4, 0x1CD).addRange(0x1F1, 0x1F4).addRange(0x1F6, 0x1F8).addRange(0x23A, 0x23B).addRange(0x23D, 0x23E).addRange(0x243, 0x246).addRange(0x2B0, 0x2B8).addRange(0x2D8, 0x2DD).addRange(0x2E0, 0x2E4).addRange(0x340, 0x341).addRange(0x343, 0x345).addRange(0x37E, 0x37F).addRange(0x384, 0x38A).addRange(0x38E, 0x38F).addRange(0x391, 0x3A1).addRange(0x3A3, 0x3AB).addRange(0x3CF, 0x3D6).addRange(0x3F0, 0x3F2).addRange(0x3F4, 0x3F5).addRange(0x3F9, 0x3FA).addRange(0x3FD, 0x42F).addRange(0x4C0, 0x4C1).addRange(0x531, 0x556).addRange(0x675, 0x678).addRange(0x958, 0x95F).addRange(0x9DC, 0x9DD).addRange(0xA59, 0xA5B).addRange(0xB5C, 0xB5D).addRange(0xEDC, 0xEDD); +set.addRange(0xF75, 0xF79).addRange(0x10A0, 0x10C5).addRange(0x115F, 0x1160).addRange(0x13F8, 0x13FD).addRange(0x17B4, 0x17B5).addRange(0x180B, 0x180F).addRange(0x1C80, 0x1C89).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1D2C, 0x1D2E).addRange(0x1D30, 0x1D3A).addRange(0x1D3C, 0x1D4D).addRange(0x1D4F, 0x1D6A).addRange(0x1D9B, 0x1DBF).addRange(0x1E9A, 0x1E9B).addRange(0x1F08, 0x1F0F).addRange(0x1F18, 0x1F1D).addRange(0x1F28, 0x1F2F).addRange(0x1F38, 0x1F3F).addRange(0x1F48, 0x1F4D).addRange(0x1F68, 0x1F6F).addRange(0x1F80, 0x1FAF).addRange(0x1FB2, 0x1FB4).addRange(0x1FB7, 0x1FC4).addRange(0x1FC7, 0x1FCF).addRange(0x1FD8, 0x1FDB).addRange(0x1FDD, 0x1FDF).addRange(0x1FE8, 0x1FEF).addRange(0x1FF2, 0x1FF4).addRange(0x1FF7, 0x1FFE).addRange(0x2000, 0x200F).addRange(0x2024, 0x2026).addRange(0x202A, 0x202F).addRange(0x2033, 0x2034).addRange(0x2036, 0x2037).addRange(0x2047, 0x2049).addRange(0x205F, 0x2071).addRange(0x2074, 0x208E).addRange(0x2090, 0x209C).addRange(0x2100, 0x2103).addRange(0x2105, 0x2107).addRange(0x2109, 0x2113).addRange(0x2115, 0x2116).addRange(0x2119, 0x211D).addRange(0x2120, 0x2122).addRange(0x212A, 0x212D).addRange(0x212F, 0x2139).addRange(0x213B, 0x2140).addRange(0x2145, 0x2149).addRange(0x2150, 0x217F).addRange(0x222C, 0x222D); +set.addRange(0x222F, 0x2230).addRange(0x2329, 0x232A).addRange(0x2460, 0x24EA).addRange(0x2A74, 0x2A76).addRange(0x2C00, 0x2C2F).addRange(0x2C62, 0x2C64).addRange(0x2C6D, 0x2C70).addRange(0x2C7C, 0x2C80).addRange(0x2F00, 0x2FD5).addRange(0x3038, 0x303A).addRange(0x309B, 0x309C).addRange(0x3131, 0x318E).addRange(0x3192, 0x319F).addRange(0x3200, 0x321E).addRange(0x3220, 0x3247).addRange(0x3250, 0x327E).addRange(0x3280, 0x33FF).addRange(0xA69C, 0xA69D).addRange(0xA77D, 0xA77E).addRange(0xA7AA, 0xA7AE).addRange(0xA7B0, 0xA7B4).addRange(0xA7C4, 0xA7C7).addRange(0xA7CB, 0xA7CC).addRange(0xA7F1, 0xA7F5).addRange(0xA7F8, 0xA7F9).addRange(0xAB5C, 0xAB5F).addRange(0xAB70, 0xABBF).addRange(0xF900, 0xFA0D).addRange(0xFA15, 0xFA1E).addRange(0xFA25, 0xFA26).addRange(0xFA2A, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1F, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFC).addRange(0xFE00, 0xFE19).addRange(0xFE30, 0xFE44).addRange(0xFE47, 0xFE52).addRange(0xFE54, 0xFE66).addRange(0xFE68, 0xFE6B).addRange(0xFE70, 0xFE72).addRange(0xFE76, 0xFEFC).addRange(0xFF01, 0xFFBE); +set.addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0xFFE0, 0xFFE6).addRange(0xFFE8, 0xFFEE).addRange(0xFFF0, 0xFFF8).addRange(0x10400, 0x10427).addRange(0x104B0, 0x104D3).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10781, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10C80, 0x10CB2).addRange(0x10D50, 0x10D65).addRange(0x118A0, 0x118BF).addRange(0x16E40, 0x16E5F).addRange(0x16EA0, 0x16EB8).addRange(0x1BCA0, 0x1BCA3).addRange(0x1CCD6, 0x1CCF9).addRange(0x1D15E, 0x1D164).addRange(0x1D173, 0x1D17A).addRange(0x1D1BB, 0x1D1C0).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D7CB).addRange(0x1D7CE, 0x1D7FF).addRange(0x1E030, 0x1E06D).addRange(0x1E900, 0x1E921).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37); +set.addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1F100, 0x1F10A).addRange(0x1F110, 0x1F12E).addRange(0x1F130, 0x1F14F).addRange(0x1F16A, 0x1F16C).addRange(0x1F200, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F250, 0x1F251).addRange(0x1FBF0, 0x1FBF9).addRange(0x2F800, 0x2FA1D).addRange(0xE0000, 0xE0FFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Titlecased.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Titlecased.js new file mode 100644 index 0000000000000000000000000000000000000000..642d90aaea8857a418091903a794480db91bb0fc --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Titlecased.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0xB5, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x12F, 0x131, 0x133, 0x135, 0x137, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x183, 0x185, 0x188, 0x18C, 0x192, 0x195, 0x19E, 0x1A1, 0x1A3, 0x1A5, 0x1A8, 0x1AD, 0x1B0, 0x1B4, 0x1B6, 0x1B9, 0x1BD, 0x1BF, 0x1C4, 0x1CC, 0x1CE, 0x1D0, 0x1D2, 0x1D4, 0x1D6, 0x1D8, 0x1DA, 0x1DF, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x1E9, 0x1EB, 0x1ED, 0x1F3, 0x1F5, 0x1F9, 0x1FB, 0x1FD, 0x1FF, 0x201, 0x203, 0x205, 0x207, 0x209, 0x20B, 0x20D, 0x20F, 0x211, 0x213, 0x215, 0x217, 0x219, 0x21B, 0x21D, 0x21F, 0x223, 0x225, 0x227, 0x229, 0x22B, 0x22D, 0x22F, 0x231, 0x233, 0x23C, 0x242, 0x247, 0x249, 0x24B, 0x24D, 0x259, 0x26F, 0x275, 0x27D, 0x280, 0x292, 0x345, 0x371, 0x373, 0x377, 0x390, 0x3D9, 0x3DB, 0x3DD, 0x3DF, 0x3E1, 0x3E3, 0x3E5, 0x3E7, 0x3E9, 0x3EB, 0x3ED, 0x3F5, 0x3F8, 0x3FB, 0x461, 0x463, 0x465, 0x467, 0x469, 0x46B, 0x46D, 0x46F, 0x471, 0x473, 0x475, 0x477, 0x479, 0x47B, 0x47D, 0x47F, 0x481, 0x48B, 0x48D, 0x48F, 0x491, 0x493, 0x495, 0x497, 0x499, 0x49B, 0x49D, 0x49F, 0x4A1, 0x4A3, 0x4A5, 0x4A7, 0x4A9, 0x4AB, 0x4AD, 0x4AF, 0x4B1, 0x4B3, 0x4B5, 0x4B7, 0x4B9, 0x4BB, 0x4BD, 0x4BF, 0x4C2, 0x4C4, 0x4C6, 0x4C8, 0x4CA, 0x4CC, 0x4D1, 0x4D3, 0x4D5, 0x4D7, 0x4D9, 0x4DB, 0x4DD, 0x4DF, 0x4E1, 0x4E3, 0x4E5, 0x4E7, 0x4E9, 0x4EB, 0x4ED, 0x4EF, 0x4F1, 0x4F3, 0x4F5, 0x4F7, 0x4F9, 0x4FB, 0x4FD, 0x4FF, 0x501, 0x503, 0x505, 0x507, 0x509, 0x50B, 0x50D, 0x50F, 0x511, 0x513, 0x515, 0x517, 0x519, 0x51B, 0x51D, 0x51F, 0x521, 0x523, 0x525, 0x527, 0x529, 0x52B, 0x52D, 0x52F, 0x1C8A, 0x1D79, 0x1D7D, 0x1D8E, 0x1E01, 0x1E03, 0x1E05, 0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13, 0x1E15, 0x1E17, 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27, 0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39, 0x1E3B, 0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F, 0x1E51, 0x1E53, 0x1E55, 0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63, 0x1E65, 0x1E67, 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77, 0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89, 0x1E8B, 0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9, 0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, 0x1ED1, 0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EE3, 0x1EE5, 0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9, 0x1EFB, 0x1EFD, 0x1FBE, 0x214E, 0x2184, 0x2C61, 0x2C68, 0x2C6A, 0x2C6C, 0x2C73, 0x2C76, 0x2C81, 0x2C83, 0x2C85, 0x2C87, 0x2C89, 0x2C8B, 0x2C8D, 0x2C8F, 0x2C91, 0x2C93, 0x2C95, 0x2C97, 0x2C99, 0x2C9B, 0x2C9D, 0x2C9F, 0x2CA1, 0x2CA3, 0x2CA5, 0x2CA7, 0x2CA9, 0x2CAB, 0x2CAD, 0x2CAF, 0x2CB1, 0x2CB3, 0x2CB5, 0x2CB7, 0x2CB9, 0x2CBB, 0x2CBD, 0x2CBF, 0x2CC1, 0x2CC3, 0x2CC5, 0x2CC7, 0x2CC9, 0x2CCB, 0x2CCD, 0x2CCF, 0x2CD1, 0x2CD3, 0x2CD5, 0x2CD7, 0x2CD9, 0x2CDB, 0x2CDD, 0x2CDF, 0x2CE1, 0x2CE3, 0x2CEC, 0x2CEE, 0x2CF3, 0x2D27, 0x2D2D, 0xA641, 0xA643, 0xA645, 0xA647, 0xA649, 0xA64B, 0xA64D, 0xA64F, 0xA651, 0xA653, 0xA655, 0xA657, 0xA659, 0xA65B, 0xA65D, 0xA65F, 0xA661, 0xA663, 0xA665, 0xA667, 0xA669, 0xA66B, 0xA66D, 0xA681, 0xA683, 0xA685, 0xA687, 0xA689, 0xA68B, 0xA68D, 0xA68F, 0xA691, 0xA693, 0xA695, 0xA697, 0xA699, 0xA69B, 0xA723, 0xA725, 0xA727, 0xA729, 0xA72B, 0xA72D, 0xA72F, 0xA733, 0xA735, 0xA737, 0xA739, 0xA73B, 0xA73D, 0xA73F, 0xA741, 0xA743, 0xA745, 0xA747, 0xA749, 0xA74B, 0xA74D, 0xA74F, 0xA751, 0xA753, 0xA755, 0xA757, 0xA759, 0xA75B, 0xA75D, 0xA75F, 0xA761, 0xA763, 0xA765, 0xA767, 0xA769, 0xA76B, 0xA76D, 0xA76F, 0xA77A, 0xA77C, 0xA77F, 0xA781, 0xA783, 0xA785, 0xA787, 0xA78C, 0xA791, 0xA797, 0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3, 0xA7A5, 0xA7A7, 0xA7A9, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C1, 0xA7C3, 0xA7C8, 0xA7CA, 0xA7CD, 0xA7CF, 0xA7D1, 0xA7D3, 0xA7D5, 0xA7D7, 0xA7D9, 0xA7DB, 0xA7F6, 0xAB53); +set.addRange(0x61, 0x7A).addRange(0xDF, 0xF6).addRange(0xF8, 0xFF).addRange(0x148, 0x149).addRange(0x17E, 0x180).addRange(0x199, 0x19B).addRange(0x1C6, 0x1C7).addRange(0x1C9, 0x1CA).addRange(0x1DC, 0x1DD).addRange(0x1EF, 0x1F1).addRange(0x23F, 0x240).addRange(0x24F, 0x254).addRange(0x256, 0x257).addRange(0x25B, 0x25C).addRange(0x260, 0x261).addRange(0x263, 0x266).addRange(0x268, 0x26C).addRange(0x271, 0x272).addRange(0x282, 0x283).addRange(0x287, 0x28C).addRange(0x29D, 0x29E).addRange(0x37B, 0x37D).addRange(0x3AC, 0x3CE).addRange(0x3D0, 0x3D1).addRange(0x3D5, 0x3D7).addRange(0x3EF, 0x3F3).addRange(0x430, 0x45F).addRange(0x4CE, 0x4CF).addRange(0x561, 0x587).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C88).addRange(0x1E95, 0x1E9B).addRange(0x1EFF, 0x1F07).addRange(0x1F10, 0x1F15).addRange(0x1F20, 0x1F27).addRange(0x1F30, 0x1F37).addRange(0x1F40, 0x1F45).addRange(0x1F50, 0x1F57).addRange(0x1F60, 0x1F67).addRange(0x1F70, 0x1F7D).addRange(0x1F80, 0x1F87).addRange(0x1F90, 0x1F97).addRange(0x1FA0, 0x1FA7).addRange(0x1FB0, 0x1FB4).addRange(0x1FB6, 0x1FB7).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FC7).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FD7).addRange(0x1FE0, 0x1FE7).addRange(0x1FF2, 0x1FF4); +set.addRange(0x1FF6, 0x1FF7).addRange(0x2170, 0x217F).addRange(0x24D0, 0x24E9).addRange(0x2C30, 0x2C5F).addRange(0x2C65, 0x2C66).addRange(0x2D00, 0x2D25).addRange(0xA793, 0xA794).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF41, 0xFF5A).addRange(0x10428, 0x1044F).addRange(0x104D8, 0x104FB).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10CC0, 0x10CF2).addRange(0x10D70, 0x10D85).addRange(0x118C0, 0x118DF).addRange(0x16E60, 0x16E7F).addRange(0x16EBB, 0x16ED3).addRange(0x1E922, 0x1E943); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Uppercased.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Uppercased.js new file mode 100644 index 0000000000000000000000000000000000000000..0501f97af6aed9167e786f7d4e364ef78e27d7d4 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Uppercased.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0xB5, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x12F, 0x131, 0x133, 0x135, 0x137, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x183, 0x185, 0x188, 0x18C, 0x192, 0x195, 0x19E, 0x1A1, 0x1A3, 0x1A5, 0x1A8, 0x1AD, 0x1B0, 0x1B4, 0x1B6, 0x1B9, 0x1BD, 0x1BF, 0x1CE, 0x1D0, 0x1D2, 0x1D4, 0x1D6, 0x1D8, 0x1DA, 0x1DF, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x1E9, 0x1EB, 0x1ED, 0x1F5, 0x1F9, 0x1FB, 0x1FD, 0x1FF, 0x201, 0x203, 0x205, 0x207, 0x209, 0x20B, 0x20D, 0x20F, 0x211, 0x213, 0x215, 0x217, 0x219, 0x21B, 0x21D, 0x21F, 0x223, 0x225, 0x227, 0x229, 0x22B, 0x22D, 0x22F, 0x231, 0x233, 0x23C, 0x242, 0x247, 0x249, 0x24B, 0x24D, 0x259, 0x26F, 0x275, 0x27D, 0x280, 0x292, 0x345, 0x371, 0x373, 0x377, 0x390, 0x3D9, 0x3DB, 0x3DD, 0x3DF, 0x3E1, 0x3E3, 0x3E5, 0x3E7, 0x3E9, 0x3EB, 0x3ED, 0x3F5, 0x3F8, 0x3FB, 0x461, 0x463, 0x465, 0x467, 0x469, 0x46B, 0x46D, 0x46F, 0x471, 0x473, 0x475, 0x477, 0x479, 0x47B, 0x47D, 0x47F, 0x481, 0x48B, 0x48D, 0x48F, 0x491, 0x493, 0x495, 0x497, 0x499, 0x49B, 0x49D, 0x49F, 0x4A1, 0x4A3, 0x4A5, 0x4A7, 0x4A9, 0x4AB, 0x4AD, 0x4AF, 0x4B1, 0x4B3, 0x4B5, 0x4B7, 0x4B9, 0x4BB, 0x4BD, 0x4BF, 0x4C2, 0x4C4, 0x4C6, 0x4C8, 0x4CA, 0x4CC, 0x4D1, 0x4D3, 0x4D5, 0x4D7, 0x4D9, 0x4DB, 0x4DD, 0x4DF, 0x4E1, 0x4E3, 0x4E5, 0x4E7, 0x4E9, 0x4EB, 0x4ED, 0x4EF, 0x4F1, 0x4F3, 0x4F5, 0x4F7, 0x4F9, 0x4FB, 0x4FD, 0x4FF, 0x501, 0x503, 0x505, 0x507, 0x509, 0x50B, 0x50D, 0x50F, 0x511, 0x513, 0x515, 0x517, 0x519, 0x51B, 0x51D, 0x51F, 0x521, 0x523, 0x525, 0x527, 0x529, 0x52B, 0x52D, 0x52F, 0x1C8A, 0x1D79, 0x1D7D, 0x1D8E, 0x1E01, 0x1E03, 0x1E05, 0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13, 0x1E15, 0x1E17, 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27, 0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39, 0x1E3B, 0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F, 0x1E51, 0x1E53, 0x1E55, 0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63, 0x1E65, 0x1E67, 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77, 0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89, 0x1E8B, 0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9, 0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, 0x1ED1, 0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EE3, 0x1EE5, 0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9, 0x1EFB, 0x1EFD, 0x1FBC, 0x1FBE, 0x1FCC, 0x1FFC, 0x214E, 0x2184, 0x2C61, 0x2C68, 0x2C6A, 0x2C6C, 0x2C73, 0x2C76, 0x2C81, 0x2C83, 0x2C85, 0x2C87, 0x2C89, 0x2C8B, 0x2C8D, 0x2C8F, 0x2C91, 0x2C93, 0x2C95, 0x2C97, 0x2C99, 0x2C9B, 0x2C9D, 0x2C9F, 0x2CA1, 0x2CA3, 0x2CA5, 0x2CA7, 0x2CA9, 0x2CAB, 0x2CAD, 0x2CAF, 0x2CB1, 0x2CB3, 0x2CB5, 0x2CB7, 0x2CB9, 0x2CBB, 0x2CBD, 0x2CBF, 0x2CC1, 0x2CC3, 0x2CC5, 0x2CC7, 0x2CC9, 0x2CCB, 0x2CCD, 0x2CCF, 0x2CD1, 0x2CD3, 0x2CD5, 0x2CD7, 0x2CD9, 0x2CDB, 0x2CDD, 0x2CDF, 0x2CE1, 0x2CE3, 0x2CEC, 0x2CEE, 0x2CF3, 0x2D27, 0x2D2D, 0xA641, 0xA643, 0xA645, 0xA647, 0xA649, 0xA64B, 0xA64D, 0xA64F, 0xA651, 0xA653, 0xA655, 0xA657, 0xA659, 0xA65B, 0xA65D, 0xA65F, 0xA661, 0xA663, 0xA665, 0xA667, 0xA669, 0xA66B, 0xA66D, 0xA681, 0xA683, 0xA685, 0xA687, 0xA689, 0xA68B, 0xA68D, 0xA68F, 0xA691, 0xA693, 0xA695, 0xA697, 0xA699, 0xA69B, 0xA723, 0xA725, 0xA727, 0xA729, 0xA72B, 0xA72D, 0xA72F, 0xA733, 0xA735, 0xA737, 0xA739, 0xA73B, 0xA73D, 0xA73F, 0xA741, 0xA743, 0xA745, 0xA747, 0xA749, 0xA74B, 0xA74D, 0xA74F, 0xA751, 0xA753, 0xA755, 0xA757, 0xA759, 0xA75B, 0xA75D, 0xA75F, 0xA761, 0xA763, 0xA765, 0xA767, 0xA769, 0xA76B, 0xA76D, 0xA76F, 0xA77A, 0xA77C, 0xA77F, 0xA781, 0xA783, 0xA785, 0xA787, 0xA78C, 0xA791, 0xA797, 0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3, 0xA7A5, 0xA7A7, 0xA7A9, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C1, 0xA7C3, 0xA7C8, 0xA7CA, 0xA7CD, 0xA7CF, 0xA7D1, 0xA7D3, 0xA7D5, 0xA7D7, 0xA7D9, 0xA7DB, 0xA7F6, 0xAB53); +set.addRange(0x61, 0x7A).addRange(0xDF, 0xF6).addRange(0xF8, 0xFF).addRange(0x148, 0x149).addRange(0x17E, 0x180).addRange(0x199, 0x19B).addRange(0x1C5, 0x1C6).addRange(0x1C8, 0x1C9).addRange(0x1CB, 0x1CC).addRange(0x1DC, 0x1DD).addRange(0x1EF, 0x1F0).addRange(0x1F2, 0x1F3).addRange(0x23F, 0x240).addRange(0x24F, 0x254).addRange(0x256, 0x257).addRange(0x25B, 0x25C).addRange(0x260, 0x261).addRange(0x263, 0x266).addRange(0x268, 0x26C).addRange(0x271, 0x272).addRange(0x282, 0x283).addRange(0x287, 0x28C).addRange(0x29D, 0x29E).addRange(0x37B, 0x37D).addRange(0x3AC, 0x3CE).addRange(0x3D0, 0x3D1).addRange(0x3D5, 0x3D7).addRange(0x3EF, 0x3F3).addRange(0x430, 0x45F).addRange(0x4CE, 0x4CF).addRange(0x561, 0x587).addRange(0x10D0, 0x10FA).addRange(0x10FD, 0x10FF).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C88).addRange(0x1E95, 0x1E9B).addRange(0x1EFF, 0x1F07).addRange(0x1F10, 0x1F15).addRange(0x1F20, 0x1F27).addRange(0x1F30, 0x1F37).addRange(0x1F40, 0x1F45).addRange(0x1F50, 0x1F57).addRange(0x1F60, 0x1F67).addRange(0x1F70, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FB7).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FC7).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FD7).addRange(0x1FE0, 0x1FE7); +set.addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FF7).addRange(0x2170, 0x217F).addRange(0x24D0, 0x24E9).addRange(0x2C30, 0x2C5F).addRange(0x2C65, 0x2C66).addRange(0x2D00, 0x2D25).addRange(0xA793, 0xA794).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF41, 0xFF5A).addRange(0x10428, 0x1044F).addRange(0x104D8, 0x104FB).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10CC0, 0x10CF2).addRange(0x10D70, 0x10D85).addRange(0x118C0, 0x118DF).addRange(0x16E60, 0x16E7F).addRange(0x16EBB, 0x16ED3).addRange(0x1E922, 0x1E943); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Dash.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Dash.js new file mode 100644 index 0000000000000000000000000000000000000000..ce8f1645a4852a5eb6465807d133f22c4b3216af --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Dash.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2D, 0x58A, 0x5BE, 0x1400, 0x1806, 0x2053, 0x207B, 0x208B, 0x2212, 0x2E17, 0x2E1A, 0x2E40, 0x2E5D, 0x301C, 0x3030, 0x30A0, 0xFE58, 0xFE63, 0xFF0D, 0x10D6E, 0x10EAD); +set.addRange(0x2010, 0x2015).addRange(0x2E3A, 0x2E3B).addRange(0xFE31, 0xFE32); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Default_Ignorable_Code_Point.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Default_Ignorable_Code_Point.js new file mode 100644 index 0000000000000000000000000000000000000000..42d3546ab4365b584a8f0980b24b2abb03113b4e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Default_Ignorable_Code_Point.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xAD, 0x34F, 0x61C, 0x3164, 0xFEFF, 0xFFA0); +set.addRange(0x115F, 0x1160).addRange(0x17B4, 0x17B5).addRange(0x180B, 0x180F).addRange(0x200B, 0x200F).addRange(0x202A, 0x202E).addRange(0x2060, 0x206F).addRange(0xFE00, 0xFE0F).addRange(0xFFF0, 0xFFF8).addRange(0x1BCA0, 0x1BCA3).addRange(0x1D173, 0x1D17A).addRange(0xE0000, 0xE0FFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Deprecated.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Deprecated.js new file mode 100644 index 0000000000000000000000000000000000000000..428063a063715d278691b32955c11e29073b4cb2 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Deprecated.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x149, 0x673, 0xF77, 0xF79, 0xE0001); +set.addRange(0x17A3, 0x17A4).addRange(0x206A, 0x206F).addRange(0x2329, 0x232A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Diacritic.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Diacritic.js new file mode 100644 index 0000000000000000000000000000000000000000..e9bbdad1e114fa50536612dd04161d70925d11a9 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Diacritic.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0x5E, 0x60, 0xA8, 0xAF, 0xB4, 0x37A, 0x559, 0x5BF, 0x5C7, 0x93C, 0x94D, 0x971, 0x9BC, 0x9CD, 0xA3C, 0xA4D, 0xABC, 0xACD, 0xB3C, 0xB4D, 0xB55, 0xBCD, 0xC3C, 0xC4D, 0xCBC, 0xCCD, 0xD4D, 0xDCA, 0xE3A, 0xE4E, 0xEBA, 0xF35, 0xF37, 0xF39, 0xFC6, 0x1037, 0x108F, 0x1734, 0x17DD, 0x1A60, 0x1A7F, 0x1B34, 0x1B44, 0x1BE6, 0x1CED, 0x1CF4, 0x1FBD, 0x2E2F, 0x30FC, 0xA66F, 0xA67F, 0xA7F1, 0xA806, 0xA82C, 0xA8C4, 0xA953, 0xA9B3, 0xA9C0, 0xA9E5, 0xAAF6, 0xFB1E, 0xFF3E, 0xFF40, 0xFF70, 0xFFE3, 0x102E0, 0x10A3F, 0x10D4E, 0x10EFA, 0x11046, 0x11070, 0x11173, 0x111C0, 0x1134D, 0x11442, 0x11446, 0x1163F, 0x1172B, 0x11943, 0x119E0, 0x11A34, 0x11A47, 0x11A99, 0x11C3F, 0x11D42, 0x11D97, 0x11DD9, 0x11F5A, 0x1612F, 0x1E2AE); +set.addRange(0xB7, 0xB8).addRange(0x2B0, 0x34E).addRange(0x350, 0x357).addRange(0x35D, 0x362).addRange(0x374, 0x375).addRange(0x384, 0x385).addRange(0x483, 0x487).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x64B, 0x652).addRange(0x657, 0x658).addRange(0x6DF, 0x6E0).addRange(0x6E5, 0x6E6).addRange(0x6EA, 0x6EC).addRange(0x730, 0x74A).addRange(0x7A6, 0x7B0).addRange(0x7EB, 0x7F5).addRange(0x818, 0x819).addRange(0x898, 0x89F).addRange(0x8C9, 0x8D2).addRange(0x8E3, 0x8FE).addRange(0x951, 0x954).addRange(0xAFD, 0xAFF).addRange(0xD3B, 0xD3C).addRange(0xE47, 0xE4C).addRange(0xEC8, 0xECC).addRange(0xF18, 0xF19).addRange(0xF3E, 0xF3F).addRange(0xF82, 0xF84).addRange(0xF86, 0xF87).addRange(0x1039, 0x103A).addRange(0x1063, 0x1064).addRange(0x1069, 0x106D).addRange(0x1087, 0x108D).addRange(0x109A, 0x109B).addRange(0x135D, 0x135F).addRange(0x1714, 0x1715).addRange(0x17C9, 0x17D3).addRange(0x1939, 0x193B).addRange(0x1A75, 0x1A7C).addRange(0x1AB0, 0x1ABE).addRange(0x1AC1, 0x1ACB).addRange(0x1ACF, 0x1ADD).addRange(0x1AE0, 0x1AEB).addRange(0x1B6B, 0x1B73).addRange(0x1BAA, 0x1BAB).addRange(0x1BF2, 0x1BF3).addRange(0x1C36, 0x1C37).addRange(0x1C78, 0x1C7D).addRange(0x1CD0, 0x1CE8); +set.addRange(0x1CF7, 0x1CF9).addRange(0x1D2C, 0x1D6A).addRange(0x1D9B, 0x1DBE).addRange(0x1DC4, 0x1DCF).addRange(0x1DF5, 0x1DFF).addRange(0x1FBF, 0x1FC1).addRange(0x1FCD, 0x1FCF).addRange(0x1FDD, 0x1FDF).addRange(0x1FED, 0x1FEF).addRange(0x1FFD, 0x1FFE).addRange(0x2CEF, 0x2CF1).addRange(0x302A, 0x302F).addRange(0x3099, 0x309C).addRange(0xA67C, 0xA67D).addRange(0xA69C, 0xA69D).addRange(0xA6F0, 0xA6F1).addRange(0xA700, 0xA721).addRange(0xA788, 0xA78A).addRange(0xA7F8, 0xA7F9).addRange(0xA8E0, 0xA8F1).addRange(0xA92B, 0xA92E).addRange(0xAA7B, 0xAA7D).addRange(0xAABF, 0xAAC2).addRange(0xAB5B, 0xAB5F).addRange(0xAB69, 0xAB6B).addRange(0xABEC, 0xABED).addRange(0xFE20, 0xFE2F).addRange(0xFF9E, 0xFF9F).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10A38, 0x10A3A).addRange(0x10AE5, 0x10AE6).addRange(0x10D22, 0x10D27).addRange(0x10D69, 0x10D6D).addRange(0x10EFD, 0x10EFF).addRange(0x10F46, 0x10F50).addRange(0x10F82, 0x10F85).addRange(0x110B9, 0x110BA).addRange(0x11133, 0x11134).addRange(0x111CA, 0x111CC).addRange(0x11235, 0x11236).addRange(0x112E9, 0x112EA).addRange(0x1133B, 0x1133C).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x113CE, 0x113D0).addRange(0x113D2, 0x113D3).addRange(0x113E1, 0x113E2).addRange(0x114C2, 0x114C3).addRange(0x115BF, 0x115C0); +set.addRange(0x116B6, 0x116B7).addRange(0x11839, 0x1183A).addRange(0x1193D, 0x1193E).addRange(0x11D44, 0x11D45).addRange(0x11F41, 0x11F42).addRange(0x13447, 0x13455).addRange(0x16AF0, 0x16AF4).addRange(0x16B30, 0x16B36).addRange(0x16D6B, 0x16D6C).addRange(0x16F8F, 0x16F9F).addRange(0x16FF0, 0x16FF1).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D167, 0x1D169).addRange(0x1D16D, 0x1D172).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1E030, 0x1E06D).addRange(0x1E130, 0x1E136).addRange(0x1E2EC, 0x1E2EF).addRange(0x1E5EE, 0x1E5EF).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E944, 0x1E946).addRange(0x1E948, 0x1E94A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji.js new file mode 100644 index 0000000000000000000000000000000000000000..986134b5a287cd9b11436946d2558bf06f84e0c1 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0x23, 0x2A, 0xA9, 0xAE, 0x203C, 0x2049, 0x2122, 0x2139, 0x2328, 0x23CF, 0x24C2, 0x25B6, 0x25C0, 0x260E, 0x2611, 0x2618, 0x261D, 0x2620, 0x2626, 0x262A, 0x2640, 0x2642, 0x2663, 0x2668, 0x267B, 0x2699, 0x26A7, 0x26C8, 0x26D1, 0x26FD, 0x2702, 0x2705, 0x270F, 0x2712, 0x2714, 0x2716, 0x271D, 0x2721, 0x2728, 0x2744, 0x2747, 0x274C, 0x274E, 0x2757, 0x27A1, 0x27B0, 0x27BF, 0x2B50, 0x2B55, 0x3030, 0x303D, 0x3297, 0x3299, 0x1F004, 0x1F0CF, 0x1F18E, 0x1F21A, 0x1F22F, 0x1F587, 0x1F590, 0x1F5A8, 0x1F5BC, 0x1F5E1, 0x1F5E3, 0x1F5E8, 0x1F5EF, 0x1F5F3, 0x1F6E9, 0x1F6F0, 0x1F7F0, 0x1FAC8); +set.addRange(0x30, 0x39).addRange(0x2194, 0x2199).addRange(0x21A9, 0x21AA).addRange(0x231A, 0x231B).addRange(0x23E9, 0x23F3).addRange(0x23F8, 0x23FA).addRange(0x25AA, 0x25AB).addRange(0x25FB, 0x25FE).addRange(0x2600, 0x2604).addRange(0x2614, 0x2615).addRange(0x2622, 0x2623).addRange(0x262E, 0x262F).addRange(0x2638, 0x263A).addRange(0x2648, 0x2653).addRange(0x265F, 0x2660).addRange(0x2665, 0x2666).addRange(0x267E, 0x267F).addRange(0x2692, 0x2697).addRange(0x269B, 0x269C).addRange(0x26A0, 0x26A1).addRange(0x26AA, 0x26AB).addRange(0x26B0, 0x26B1).addRange(0x26BD, 0x26BE).addRange(0x26C4, 0x26C5).addRange(0x26CE, 0x26CF).addRange(0x26D3, 0x26D4).addRange(0x26E9, 0x26EA).addRange(0x26F0, 0x26F5).addRange(0x26F7, 0x26FA).addRange(0x2708, 0x270D).addRange(0x2733, 0x2734).addRange(0x2753, 0x2755).addRange(0x2763, 0x2764).addRange(0x2795, 0x2797).addRange(0x2934, 0x2935).addRange(0x2B05, 0x2B07).addRange(0x2B1B, 0x2B1C).addRange(0x1F170, 0x1F171).addRange(0x1F17E, 0x1F17F).addRange(0x1F191, 0x1F19A).addRange(0x1F1E6, 0x1F1FF).addRange(0x1F201, 0x1F202).addRange(0x1F232, 0x1F23A).addRange(0x1F250, 0x1F251).addRange(0x1F300, 0x1F321).addRange(0x1F324, 0x1F393).addRange(0x1F396, 0x1F397).addRange(0x1F399, 0x1F39B).addRange(0x1F39E, 0x1F3F0).addRange(0x1F3F3, 0x1F3F5).addRange(0x1F3F7, 0x1F4FD); +set.addRange(0x1F4FF, 0x1F53D).addRange(0x1F549, 0x1F54E).addRange(0x1F550, 0x1F567).addRange(0x1F56F, 0x1F570).addRange(0x1F573, 0x1F57A).addRange(0x1F58A, 0x1F58D).addRange(0x1F595, 0x1F596).addRange(0x1F5A4, 0x1F5A5).addRange(0x1F5B1, 0x1F5B2).addRange(0x1F5C2, 0x1F5C4).addRange(0x1F5D1, 0x1F5D3).addRange(0x1F5DC, 0x1F5DE).addRange(0x1F5FA, 0x1F64F).addRange(0x1F680, 0x1F6C5).addRange(0x1F6CB, 0x1F6D2).addRange(0x1F6D5, 0x1F6D8).addRange(0x1F6DC, 0x1F6E5).addRange(0x1F6EB, 0x1F6EC).addRange(0x1F6F3, 0x1F6FC).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F90C, 0x1F93A).addRange(0x1F93C, 0x1F945).addRange(0x1F947, 0x1F9FF).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA8A).addRange(0x1FA8E, 0x1FAC6).addRange(0x1FACD, 0x1FADC).addRange(0x1FADF, 0x1FAEA).addRange(0x1FAEF, 0x1FAF8); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Component.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Component.js new file mode 100644 index 0000000000000000000000000000000000000000..f28a5d02602417d78fd64e8644f37528cc9c3c3d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Component.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x23, 0x2A, 0x200D, 0x20E3, 0xFE0F); +set.addRange(0x30, 0x39).addRange(0x1F1E6, 0x1F1FF).addRange(0x1F3FB, 0x1F3FF).addRange(0x1F9B0, 0x1F9B3).addRange(0xE0020, 0xE007F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Modifier.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Modifier.js new file mode 100644 index 0000000000000000000000000000000000000000..26bededa100e1c5248d6206a9b0efb2614d9d4ac --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Modifier.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1F3FB, 0x1F3FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Modifier_Base.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Modifier_Base.js new file mode 100644 index 0000000000000000000000000000000000000000..2345b20837ffe70a353f65a62e2bf079c7dcbff3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Modifier_Base.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x261D, 0x26F9, 0x1F385, 0x1F3C7, 0x1F47C, 0x1F48F, 0x1F491, 0x1F4AA, 0x1F57A, 0x1F590, 0x1F6A3, 0x1F6C0, 0x1F6CC, 0x1F90C, 0x1F90F, 0x1F926, 0x1F977, 0x1F9BB); +set.addRange(0x270A, 0x270D).addRange(0x1F3C2, 0x1F3C4).addRange(0x1F3CA, 0x1F3CC).addRange(0x1F442, 0x1F443).addRange(0x1F446, 0x1F450).addRange(0x1F466, 0x1F478).addRange(0x1F481, 0x1F483).addRange(0x1F485, 0x1F487).addRange(0x1F574, 0x1F575).addRange(0x1F595, 0x1F596).addRange(0x1F645, 0x1F647).addRange(0x1F64B, 0x1F64F).addRange(0x1F6B4, 0x1F6B6).addRange(0x1F918, 0x1F91F).addRange(0x1F930, 0x1F939).addRange(0x1F93C, 0x1F93E).addRange(0x1F9B5, 0x1F9B6).addRange(0x1F9B8, 0x1F9B9).addRange(0x1F9CD, 0x1F9CF).addRange(0x1F9D1, 0x1F9DD).addRange(0x1FAC3, 0x1FAC5).addRange(0x1FAF0, 0x1FAF8); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Presentation.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Presentation.js new file mode 100644 index 0000000000000000000000000000000000000000..e88ae0c4dd02af9d14f96a57d0bf85096729172a --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Presentation.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x23F0, 0x23F3, 0x267F, 0x2693, 0x26A1, 0x26CE, 0x26D4, 0x26EA, 0x26F5, 0x26FA, 0x26FD, 0x2705, 0x2728, 0x274C, 0x274E, 0x2757, 0x27B0, 0x27BF, 0x2B50, 0x2B55, 0x1F004, 0x1F0CF, 0x1F18E, 0x1F201, 0x1F21A, 0x1F22F, 0x1F3F4, 0x1F440, 0x1F57A, 0x1F5A4, 0x1F6CC, 0x1F7F0, 0x1FAC8); +set.addRange(0x231A, 0x231B).addRange(0x23E9, 0x23EC).addRange(0x25FD, 0x25FE).addRange(0x2614, 0x2615).addRange(0x2648, 0x2653).addRange(0x26AA, 0x26AB).addRange(0x26BD, 0x26BE).addRange(0x26C4, 0x26C5).addRange(0x26F2, 0x26F3).addRange(0x270A, 0x270B).addRange(0x2753, 0x2755).addRange(0x2795, 0x2797).addRange(0x2B1B, 0x2B1C).addRange(0x1F191, 0x1F19A).addRange(0x1F1E6, 0x1F1FF).addRange(0x1F232, 0x1F236).addRange(0x1F238, 0x1F23A).addRange(0x1F250, 0x1F251).addRange(0x1F300, 0x1F320).addRange(0x1F32D, 0x1F335).addRange(0x1F337, 0x1F37C).addRange(0x1F37E, 0x1F393).addRange(0x1F3A0, 0x1F3CA).addRange(0x1F3CF, 0x1F3D3).addRange(0x1F3E0, 0x1F3F0).addRange(0x1F3F8, 0x1F43E).addRange(0x1F442, 0x1F4FC).addRange(0x1F4FF, 0x1F53D).addRange(0x1F54B, 0x1F54E).addRange(0x1F550, 0x1F567).addRange(0x1F595, 0x1F596).addRange(0x1F5FB, 0x1F64F).addRange(0x1F680, 0x1F6C5).addRange(0x1F6D0, 0x1F6D2).addRange(0x1F6D5, 0x1F6D8).addRange(0x1F6DC, 0x1F6DF).addRange(0x1F6EB, 0x1F6EC).addRange(0x1F6F4, 0x1F6FC).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F90C, 0x1F93A).addRange(0x1F93C, 0x1F945).addRange(0x1F947, 0x1F9FF).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA8A).addRange(0x1FA8E, 0x1FAC6).addRange(0x1FACD, 0x1FADC).addRange(0x1FADF, 0x1FAEA).addRange(0x1FAEF, 0x1FAF8); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Extended_Pictographic.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Extended_Pictographic.js new file mode 100644 index 0000000000000000000000000000000000000000..f730b33c95ee7232d8f014bde259e3ff6261e4e6 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Extended_Pictographic.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0xA9, 0xAE, 0x203C, 0x2049, 0x2122, 0x2139, 0x2328, 0x23CF, 0x24C2, 0x25B6, 0x25C0, 0x260E, 0x2611, 0x2618, 0x261D, 0x2620, 0x2626, 0x262A, 0x2640, 0x2642, 0x2663, 0x2668, 0x267B, 0x2699, 0x26A7, 0x26C8, 0x26D1, 0x26FD, 0x2702, 0x2705, 0x270F, 0x2712, 0x2714, 0x2716, 0x271D, 0x2721, 0x2728, 0x2744, 0x2747, 0x274C, 0x274E, 0x2757, 0x27A1, 0x27B0, 0x27BF, 0x2B50, 0x2B55, 0x3030, 0x303D, 0x3297, 0x3299, 0x1F004, 0x1F0C0, 0x1F18E, 0x1F21A, 0x1F22F, 0x1F587, 0x1F590, 0x1F5A8, 0x1F5BC, 0x1F5E1, 0x1F5E3, 0x1F5E8, 0x1F5EF, 0x1F5F3, 0x1F6E9); +set.addRange(0x2194, 0x2199).addRange(0x21A9, 0x21AA).addRange(0x231A, 0x231B).addRange(0x23E9, 0x23F3).addRange(0x23F8, 0x23FA).addRange(0x25AA, 0x25AB).addRange(0x25FB, 0x25FE).addRange(0x2600, 0x2604).addRange(0x2614, 0x2615).addRange(0x2622, 0x2623).addRange(0x262E, 0x262F).addRange(0x2638, 0x263A).addRange(0x2648, 0x2653).addRange(0x265F, 0x2660).addRange(0x2665, 0x2666).addRange(0x267E, 0x267F).addRange(0x2692, 0x2697).addRange(0x269B, 0x269C).addRange(0x26A0, 0x26A1).addRange(0x26AA, 0x26AB).addRange(0x26B0, 0x26B1).addRange(0x26BD, 0x26BE).addRange(0x26C4, 0x26C5).addRange(0x26CE, 0x26CF).addRange(0x26D3, 0x26D4).addRange(0x26E9, 0x26EA).addRange(0x26F0, 0x26F5).addRange(0x26F7, 0x26FA).addRange(0x2708, 0x270D).addRange(0x2733, 0x2734).addRange(0x2753, 0x2755).addRange(0x2763, 0x2764).addRange(0x2795, 0x2797).addRange(0x2934, 0x2935).addRange(0x2B05, 0x2B07).addRange(0x2B1B, 0x2B1C).addRange(0x1F02C, 0x1F02F).addRange(0x1F094, 0x1F09F).addRange(0x1F0AF, 0x1F0B0).addRange(0x1F0CF, 0x1F0D0).addRange(0x1F0F6, 0x1F0FF).addRange(0x1F170, 0x1F171).addRange(0x1F17E, 0x1F17F).addRange(0x1F191, 0x1F19A).addRange(0x1F1AE, 0x1F1E5).addRange(0x1F201, 0x1F20F).addRange(0x1F232, 0x1F23A).addRange(0x1F23C, 0x1F23F).addRange(0x1F249, 0x1F25F).addRange(0x1F266, 0x1F321).addRange(0x1F324, 0x1F393); +set.addRange(0x1F396, 0x1F397).addRange(0x1F399, 0x1F39B).addRange(0x1F39E, 0x1F3F0).addRange(0x1F3F3, 0x1F3F5).addRange(0x1F3F7, 0x1F3FA).addRange(0x1F400, 0x1F4FD).addRange(0x1F4FF, 0x1F53D).addRange(0x1F549, 0x1F54E).addRange(0x1F550, 0x1F567).addRange(0x1F56F, 0x1F570).addRange(0x1F573, 0x1F57A).addRange(0x1F58A, 0x1F58D).addRange(0x1F595, 0x1F596).addRange(0x1F5A4, 0x1F5A5).addRange(0x1F5B1, 0x1F5B2).addRange(0x1F5C2, 0x1F5C4).addRange(0x1F5D1, 0x1F5D3).addRange(0x1F5DC, 0x1F5DE).addRange(0x1F5FA, 0x1F64F).addRange(0x1F680, 0x1F6C5).addRange(0x1F6CB, 0x1F6D2).addRange(0x1F6D5, 0x1F6E5).addRange(0x1F6EB, 0x1F6F0).addRange(0x1F6F3, 0x1F6FF).addRange(0x1F7DA, 0x1F7FF).addRange(0x1F80C, 0x1F80F).addRange(0x1F848, 0x1F84F).addRange(0x1F85A, 0x1F85F).addRange(0x1F888, 0x1F88F).addRange(0x1F8AE, 0x1F8AF).addRange(0x1F8BC, 0x1F8BF).addRange(0x1F8C2, 0x1F8CF).addRange(0x1F8D9, 0x1F8FF).addRange(0x1F90C, 0x1F93A).addRange(0x1F93C, 0x1F945).addRange(0x1F947, 0x1F9FF).addRange(0x1FA58, 0x1FA5F).addRange(0x1FA6E, 0x1FAFF).addRange(0x1FC00, 0x1FFFD); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Extender.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Extender.js new file mode 100644 index 0000000000000000000000000000000000000000..1aac24efe8d52b08bfa6da5477992b85b76ae554 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Extender.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7, 0x640, 0x7FA, 0xA71, 0xAFB, 0xB55, 0xE46, 0xEC6, 0x180A, 0x1843, 0x1AA7, 0x1C36, 0x1C7B, 0x3005, 0xA015, 0xA60C, 0xA9CF, 0xA9E6, 0xAA70, 0xAADD, 0xFF70, 0x10D4E, 0x10D6A, 0x10D6F, 0x11237, 0x1135D, 0x11A98, 0x11DD9, 0x16FE3, 0x1E5EF); +set.addRange(0x2D0, 0x2D1).addRange(0x3031, 0x3035).addRange(0x309D, 0x309E).addRange(0x30FC, 0x30FE).addRange(0xAAF3, 0xAAF4).addRange(0x10781, 0x10782).addRange(0x113D2, 0x113D3).addRange(0x115C6, 0x115C8).addRange(0x16B42, 0x16B43).addRange(0x16FE0, 0x16FE1).addRange(0x16FF2, 0x16FF3).addRange(0x1E13C, 0x1E13D).addRange(0x1E944, 0x1E946); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Grapheme_Base.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Grapheme_Base.js new file mode 100644 index 0000000000000000000000000000000000000000..a6b9ad68e9a4bd6eae9102985fe0cc95e2938135 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Grapheme_Base.js @@ -0,0 +1,17 @@ +const set = require('regenerate')(0x38C, 0x5BE, 0x5C0, 0x5C3, 0x5C6, 0x61B, 0x6DE, 0x6E9, 0x710, 0x7B1, 0x81A, 0x824, 0x828, 0x85E, 0x93B, 0x9B2, 0x9BD, 0x9CE, 0xA03, 0xA5E, 0xA76, 0xA83, 0xAC9, 0xAD0, 0xAF9, 0xB3D, 0xB40, 0xB83, 0xB9C, 0xBBF, 0xBD0, 0xC3D, 0xCC1, 0xD3D, 0xDBD, 0xE84, 0xEA5, 0xEBD, 0xEC6, 0xF36, 0xF38, 0xF7F, 0xF85, 0x1031, 0x1038, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17B6, 0x18AA, 0x1940, 0x1A57, 0x1A61, 0x1BE7, 0x1BEE, 0x1CD3, 0x1CE1, 0x1CFA, 0x1F59, 0x1F5B, 0x1F5D, 0x2D27, 0x2D2D, 0xA673, 0xA952, 0xAA4D, 0xAAB1, 0xAAC0, 0xAAC2, 0xFB1D, 0xFB3E, 0x101A0, 0x10808, 0x1083C, 0x10EAD, 0x11000, 0x11075, 0x1112C, 0x111BF, 0x11288, 0x1133D, 0x1133F, 0x11350, 0x1138B, 0x1138E, 0x113B7, 0x113CA, 0x113D1, 0x11445, 0x1145D, 0x114B9, 0x114BE, 0x114C1, 0x115BE, 0x1163E, 0x116AC, 0x1171E, 0x11726, 0x11838, 0x1183B, 0x11909, 0x11A00, 0x11A50, 0x11A97, 0x11B61, 0x11B65, 0x11B67, 0x11C3E, 0x11CA9, 0x11CB1, 0x11CB4, 0x11D46, 0x11D96, 0x11D98, 0x11FB0, 0x16AF5, 0x1B132, 0x1B155, 0x1BC9C, 0x1BC9F, 0x1D245, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1E2FF, 0x1E5FF, 0x1E94B, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E, 0x1F7F0, 0x1FAC8); +set.addRange(0x20, 0x7E).addRange(0xA0, 0xAC).addRange(0xAE, 0x2FF).addRange(0x370, 0x377).addRange(0x37A, 0x37F).addRange(0x384, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x482).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x559, 0x58A).addRange(0x58D, 0x58F).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F4).addRange(0x606, 0x60F).addRange(0x61D, 0x64A).addRange(0x660, 0x66F).addRange(0x671, 0x6D5).addRange(0x6E5, 0x6E6).addRange(0x6EE, 0x70D).addRange(0x712, 0x72F).addRange(0x74D, 0x7A5).addRange(0x7C0, 0x7EA).addRange(0x7F4, 0x7FA).addRange(0x7FE, 0x815).addRange(0x830, 0x83E).addRange(0x840, 0x858).addRange(0x860, 0x86A).addRange(0x870, 0x88F).addRange(0x8A0, 0x8C9).addRange(0x903, 0x939).addRange(0x93D, 0x940).addRange(0x949, 0x94C).addRange(0x94E, 0x950).addRange(0x958, 0x961).addRange(0x964, 0x980).addRange(0x982, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BF, 0x9C0).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CC).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E1).addRange(0x9E6, 0x9FD).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28); +set.addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA40).addRange(0xA59, 0xA5C).addRange(0xA66, 0xA6F).addRange(0xA72, 0xA74).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABD, 0xAC0).addRange(0xACB, 0xACC).addRange(0xAE0, 0xAE1).addRange(0xAE6, 0xAF1).addRange(0xB02, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4C).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB61).addRange(0xB66, 0xB77).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xBC1, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCC).addRange(0xBE6, 0xBFA).addRange(0xC01, 0xC03).addRange(0xC05, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC41, 0xC44).addRange(0xC58, 0xC5A).addRange(0xC5C, 0xC5D).addRange(0xC60, 0xC61); +set.addRange(0xC66, 0xC6F).addRange(0xC77, 0xC80).addRange(0xC82, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCBD, 0xCBE).addRange(0xCC3, 0xCC4).addRange(0xCDC, 0xCDE).addRange(0xCE0, 0xCE1).addRange(0xCE6, 0xCEF).addRange(0xCF1, 0xCF3).addRange(0xD02, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD3A).addRange(0xD3F, 0xD40).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4C).addRange(0xD4E, 0xD4F).addRange(0xD54, 0xD56).addRange(0xD58, 0xD61).addRange(0xD66, 0xD7F).addRange(0xD82, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDD0, 0xDD1).addRange(0xDD8, 0xDDE).addRange(0xDE6, 0xDEF).addRange(0xDF2, 0xDF4).addRange(0xE01, 0xE30).addRange(0xE32, 0xE33).addRange(0xE3F, 0xE46).addRange(0xE4F, 0xE5B).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEB0).addRange(0xEB2, 0xEB3).addRange(0xEC0, 0xEC4).addRange(0xED0, 0xED9).addRange(0xEDC, 0xEDF).addRange(0xF00, 0xF17).addRange(0xF1A, 0xF34).addRange(0xF3A, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF88, 0xF8C).addRange(0xFBE, 0xFC5).addRange(0xFC7, 0xFCC); +set.addRange(0xFCE, 0xFDA).addRange(0x1000, 0x102C).addRange(0x103B, 0x103C).addRange(0x103F, 0x1057).addRange(0x105A, 0x105D).addRange(0x1061, 0x1070).addRange(0x1075, 0x1081).addRange(0x1083, 0x1084).addRange(0x1087, 0x108C).addRange(0x108E, 0x109C).addRange(0x109E, 0x10C5).addRange(0x10D0, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x1360, 0x137C).addRange(0x1380, 0x1399).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1400, 0x169C).addRange(0x16A0, 0x16F8).addRange(0x1700, 0x1711).addRange(0x171F, 0x1731).addRange(0x1735, 0x1736).addRange(0x1740, 0x1751).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1780, 0x17B3).addRange(0x17BE, 0x17C5).addRange(0x17C7, 0x17C8).addRange(0x17D4, 0x17DC).addRange(0x17E0, 0x17E9).addRange(0x17F0, 0x17F9).addRange(0x1800, 0x180A).addRange(0x1810, 0x1819).addRange(0x1820, 0x1878).addRange(0x1880, 0x1884).addRange(0x1887, 0x18A8).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1923, 0x1926); +set.addRange(0x1929, 0x192B).addRange(0x1930, 0x1931).addRange(0x1933, 0x1938).addRange(0x1944, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x19D0, 0x19DA).addRange(0x19DE, 0x1A16).addRange(0x1A19, 0x1A1A).addRange(0x1A1E, 0x1A55).addRange(0x1A63, 0x1A64).addRange(0x1A6D, 0x1A72).addRange(0x1A80, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1AA0, 0x1AAD).addRange(0x1B04, 0x1B33).addRange(0x1B3E, 0x1B41).addRange(0x1B45, 0x1B4C).addRange(0x1B4E, 0x1B6A).addRange(0x1B74, 0x1B7F).addRange(0x1B82, 0x1BA1).addRange(0x1BA6, 0x1BA7).addRange(0x1BAE, 0x1BE5).addRange(0x1BEA, 0x1BEC).addRange(0x1BFC, 0x1C2B).addRange(0x1C34, 0x1C35).addRange(0x1C3B, 0x1C49).addRange(0x1C4D, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CC7).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF7).addRange(0x1D00, 0x1DBF).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FC4).addRange(0x1FC6, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FDD, 0x1FEF).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFE).addRange(0x2000, 0x200A).addRange(0x2010, 0x2027).addRange(0x202F, 0x205F); +set.addRange(0x2070, 0x2071).addRange(0x2074, 0x208E).addRange(0x2090, 0x209C).addRange(0x20A0, 0x20C1).addRange(0x2100, 0x218B).addRange(0x2190, 0x2429).addRange(0x2440, 0x244A).addRange(0x2460, 0x2B73).addRange(0x2B76, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2CF9, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D6F, 0x2D70).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x2E00, 0x2E5D).addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5).addRange(0x2FF0, 0x3029).addRange(0x3030, 0x303F).addRange(0x3041, 0x3096).addRange(0x309B, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x3190, 0x31E5).addRange(0x31EF, 0x321E).addRange(0x3220, 0xA48C).addRange(0xA490, 0xA4C6).addRange(0xA4D0, 0xA62B).addRange(0xA640, 0xA66E).addRange(0xA67E, 0xA69D).addRange(0xA6A0, 0xA6EF).addRange(0xA6F2, 0xA6F7).addRange(0xA700, 0xA7DC).addRange(0xA7F1, 0xA801).addRange(0xA803, 0xA805).addRange(0xA807, 0xA80A).addRange(0xA80C, 0xA824).addRange(0xA827, 0xA82B).addRange(0xA830, 0xA839).addRange(0xA840, 0xA877).addRange(0xA880, 0xA8C3).addRange(0xA8CE, 0xA8D9); +set.addRange(0xA8F2, 0xA8FE).addRange(0xA900, 0xA925).addRange(0xA92E, 0xA946).addRange(0xA95F, 0xA97C).addRange(0xA983, 0xA9B2).addRange(0xA9B4, 0xA9B5).addRange(0xA9BA, 0xA9BB).addRange(0xA9BE, 0xA9BF).addRange(0xA9C1, 0xA9CD).addRange(0xA9CF, 0xA9D9).addRange(0xA9DE, 0xA9E4).addRange(0xA9E6, 0xA9FE).addRange(0xAA00, 0xAA28).addRange(0xAA2F, 0xAA30).addRange(0xAA33, 0xAA34).addRange(0xAA40, 0xAA42).addRange(0xAA44, 0xAA4B).addRange(0xAA50, 0xAA59).addRange(0xAA5C, 0xAA7B).addRange(0xAA7D, 0xAAAF).addRange(0xAAB5, 0xAAB6).addRange(0xAAB9, 0xAABD).addRange(0xAADB, 0xAAEB).addRange(0xAAEE, 0xAAF5).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB6B).addRange(0xAB70, 0xABE4).addRange(0xABE6, 0xABE7).addRange(0xABE9, 0xABEC).addRange(0xABF0, 0xABF9).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1F, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFDCF).addRange(0xFDF0, 0xFDFF).addRange(0xFE10, 0xFE19).addRange(0xFE30, 0xFE52).addRange(0xFE54, 0xFE66).addRange(0xFE68, 0xFE6B); +set.addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF01, 0xFF9D).addRange(0xFFA0, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0xFFE0, 0xFFE6).addRange(0xFFE8, 0xFFEE).addRange(0xFFFC, 0xFFFD).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10100, 0x10102).addRange(0x10107, 0x10133).addRange(0x10137, 0x1018E).addRange(0x10190, 0x1019C).addRange(0x101D0, 0x101FC).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x102E1, 0x102FB).addRange(0x10300, 0x10323).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x10375).addRange(0x10380, 0x1039D).addRange(0x1039F, 0x103C3).addRange(0x103C8, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104A0, 0x104A9).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x1056F, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785); +set.addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10857, 0x1089E).addRange(0x108A7, 0x108AF).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x108FB, 0x1091B).addRange(0x1091F, 0x10939).addRange(0x1093F, 0x10959).addRange(0x10980, 0x109B7).addRange(0x109BC, 0x109CF).addRange(0x109D2, 0x10A00).addRange(0x10A10, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A40, 0x10A48).addRange(0x10A50, 0x10A58).addRange(0x10A60, 0x10A9F).addRange(0x10AC0, 0x10AE4).addRange(0x10AEB, 0x10AF6).addRange(0x10B00, 0x10B35).addRange(0x10B39, 0x10B55).addRange(0x10B58, 0x10B72).addRange(0x10B78, 0x10B91).addRange(0x10B99, 0x10B9C).addRange(0x10BA9, 0x10BAF).addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10CFA, 0x10D23).addRange(0x10D30, 0x10D39).addRange(0x10D40, 0x10D65).addRange(0x10D6E, 0x10D85).addRange(0x10D8E, 0x10D8F).addRange(0x10E60, 0x10E7E).addRange(0x10E80, 0x10EA9).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC7).addRange(0x10ED0, 0x10ED8).addRange(0x10F00, 0x10F27).addRange(0x10F30, 0x10F45).addRange(0x10F51, 0x10F59).addRange(0x10F70, 0x10F81).addRange(0x10F86, 0x10F89).addRange(0x10FB0, 0x10FCB).addRange(0x10FE0, 0x10FF6).addRange(0x11002, 0x11037); +set.addRange(0x11047, 0x1104D).addRange(0x11052, 0x1106F).addRange(0x11071, 0x11072).addRange(0x11082, 0x110B2).addRange(0x110B7, 0x110B8).addRange(0x110BB, 0x110BC).addRange(0x110BE, 0x110C1).addRange(0x110D0, 0x110E8).addRange(0x110F0, 0x110F9).addRange(0x11103, 0x11126).addRange(0x11136, 0x11147).addRange(0x11150, 0x11172).addRange(0x11174, 0x11176).addRange(0x11182, 0x111B5).addRange(0x111C1, 0x111C8).addRange(0x111CD, 0x111CE).addRange(0x111D0, 0x111DF).addRange(0x111E1, 0x111F4).addRange(0x11200, 0x11211).addRange(0x11213, 0x1122E).addRange(0x11232, 0x11233).addRange(0x11238, 0x1123D).addRange(0x1123F, 0x11240).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A9).addRange(0x112B0, 0x112DE).addRange(0x112E0, 0x112E2).addRange(0x112F0, 0x112F9).addRange(0x11302, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x11341, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134C).addRange(0x1135D, 0x11363).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x113B9, 0x113BA).addRange(0x113CC, 0x113CD).addRange(0x113D3, 0x113D5).addRange(0x113D7, 0x113D8).addRange(0x11400, 0x11437).addRange(0x11440, 0x11441).addRange(0x11447, 0x1145B).addRange(0x1145F, 0x11461); +set.addRange(0x11480, 0x114AF).addRange(0x114B1, 0x114B2).addRange(0x114BB, 0x114BC).addRange(0x114C4, 0x114C7).addRange(0x114D0, 0x114D9).addRange(0x11580, 0x115AE).addRange(0x115B0, 0x115B1).addRange(0x115B8, 0x115BB).addRange(0x115C1, 0x115DB).addRange(0x11600, 0x11632).addRange(0x1163B, 0x1163C).addRange(0x11641, 0x11644).addRange(0x11650, 0x11659).addRange(0x11660, 0x1166C).addRange(0x11680, 0x116AA).addRange(0x116AE, 0x116AF).addRange(0x116B8, 0x116B9).addRange(0x116C0, 0x116C9).addRange(0x116D0, 0x116E3).addRange(0x11700, 0x1171A).addRange(0x11720, 0x11721).addRange(0x11730, 0x11746).addRange(0x11800, 0x1182E).addRange(0x118A0, 0x118F2).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x1192F).addRange(0x11931, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193F, 0x11942).addRange(0x11944, 0x11946).addRange(0x11950, 0x11959).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D3).addRange(0x119DC, 0x119DF).addRange(0x119E1, 0x119E4).addRange(0x11A0B, 0x11A32).addRange(0x11A39, 0x11A3A).addRange(0x11A3F, 0x11A46).addRange(0x11A57, 0x11A58).addRange(0x11A5C, 0x11A89).addRange(0x11A9A, 0x11AA2).addRange(0x11AB0, 0x11AF8).addRange(0x11B00, 0x11B09).addRange(0x11BC0, 0x11BE1).addRange(0x11BF0, 0x11BF9).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C2F).addRange(0x11C40, 0x11C45).addRange(0x11C50, 0x11C6C); +set.addRange(0x11C70, 0x11C8F).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D30).addRange(0x11D50, 0x11D59).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D93, 0x11D94).addRange(0x11DA0, 0x11DA9).addRange(0x11DB0, 0x11DDB).addRange(0x11DE0, 0x11DE9).addRange(0x11EE0, 0x11EF2).addRange(0x11EF5, 0x11EF8).addRange(0x11F02, 0x11F10).addRange(0x11F12, 0x11F35).addRange(0x11F3E, 0x11F3F).addRange(0x11F43, 0x11F59).addRange(0x11FC0, 0x11FF1).addRange(0x11FFF, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12470, 0x12474).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF2).addRange(0x13000, 0x1342F).addRange(0x13441, 0x13446).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x1611D).addRange(0x1612A, 0x1612C).addRange(0x16130, 0x16139).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A60, 0x16A69).addRange(0x16A6E, 0x16ABE).addRange(0x16AC0, 0x16AC9).addRange(0x16AD0, 0x16AED).addRange(0x16B00, 0x16B2F).addRange(0x16B37, 0x16B45).addRange(0x16B50, 0x16B59).addRange(0x16B5B, 0x16B61).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D79).addRange(0x16E40, 0x16E9A).addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3).addRange(0x16F00, 0x16F4A).addRange(0x16F50, 0x16F87).addRange(0x16F93, 0x16F9F).addRange(0x16FE0, 0x16FE3); +set.addRange(0x16FF2, 0x16FF6).addRange(0x17000, 0x18CD5).addRange(0x18CFF, 0x18D1E).addRange(0x18D80, 0x18DF2).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1CC00, 0x1CCFC).addRange(0x1CD00, 0x1CEB3).addRange(0x1CEBA, 0x1CED0).addRange(0x1CEE0, 0x1CEF0).addRange(0x1CF50, 0x1CFC3).addRange(0x1D000, 0x1D0F5).addRange(0x1D100, 0x1D126).addRange(0x1D129, 0x1D164).addRange(0x1D16A, 0x1D16C).addRange(0x1D183, 0x1D184).addRange(0x1D18C, 0x1D1A9).addRange(0x1D1AE, 0x1D1EA).addRange(0x1D200, 0x1D241).addRange(0x1D2C0, 0x1D2D3).addRange(0x1D2E0, 0x1D2F3).addRange(0x1D300, 0x1D356).addRange(0x1D360, 0x1D378).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D7CB).addRange(0x1D7CE, 0x1D9FF).addRange(0x1DA37, 0x1DA3A); +set.addRange(0x1DA6D, 0x1DA74).addRange(0x1DA76, 0x1DA83).addRange(0x1DA85, 0x1DA8B).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E137, 0x1E13D).addRange(0x1E140, 0x1E149).addRange(0x1E14E, 0x1E14F).addRange(0x1E290, 0x1E2AD).addRange(0x1E2C0, 0x1E2EB).addRange(0x1E2F0, 0x1E2F9).addRange(0x1E4D0, 0x1E4EB).addRange(0x1E4F0, 0x1E4F9).addRange(0x1E5D0, 0x1E5ED).addRange(0x1E5F0, 0x1E5FA).addRange(0x1E6C0, 0x1E6DE).addRange(0x1E6E0, 0x1E6E2).addRange(0x1E6E4, 0x1E6E5).addRange(0x1E6E7, 0x1E6ED).addRange(0x1E6F0, 0x1E6F4).addRange(0x1E6FE, 0x1E6FF).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E8C7, 0x1E8CF).addRange(0x1E900, 0x1E943).addRange(0x1E950, 0x1E959).addRange(0x1E95E, 0x1E95F).addRange(0x1EC71, 0x1ECB4).addRange(0x1ED01, 0x1ED3D).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB); +set.addRange(0x1EEF0, 0x1EEF1).addRange(0x1F000, 0x1F02B).addRange(0x1F030, 0x1F093).addRange(0x1F0A0, 0x1F0AE).addRange(0x1F0B1, 0x1F0BF).addRange(0x1F0C1, 0x1F0CF).addRange(0x1F0D1, 0x1F0F5).addRange(0x1F100, 0x1F1AD).addRange(0x1F1E6, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F250, 0x1F251).addRange(0x1F260, 0x1F265).addRange(0x1F300, 0x1F6D8).addRange(0x1F6DC, 0x1F6EC).addRange(0x1F6F0, 0x1F6FC).addRange(0x1F700, 0x1F7D9).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F800, 0x1F80B).addRange(0x1F810, 0x1F847).addRange(0x1F850, 0x1F859).addRange(0x1F860, 0x1F887).addRange(0x1F890, 0x1F8AD).addRange(0x1F8B0, 0x1F8BB).addRange(0x1F8C0, 0x1F8C1).addRange(0x1F8D0, 0x1F8D8).addRange(0x1F900, 0x1FA57).addRange(0x1FA60, 0x1FA6D).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA8A).addRange(0x1FA8E, 0x1FAC6).addRange(0x1FACD, 0x1FADC).addRange(0x1FADF, 0x1FAEA).addRange(0x1FAEF, 0x1FAF8).addRange(0x1FB00, 0x1FB92).addRange(0x1FB94, 0x1FBFA).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Grapheme_Extend.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Grapheme_Extend.js new file mode 100644 index 0000000000000000000000000000000000000000..4aa40b64ed62c96a41f17c81b3f0b58ca81cf1b7 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Grapheme_Extend.js @@ -0,0 +1,7 @@ +const set = require('regenerate')(0x5BF, 0x5C7, 0x670, 0x711, 0x7FD, 0x93A, 0x93C, 0x94D, 0x981, 0x9BC, 0x9BE, 0x9CD, 0x9D7, 0x9FE, 0xA3C, 0xA51, 0xA75, 0xABC, 0xACD, 0xB01, 0xB3C, 0xB4D, 0xB82, 0xBBE, 0xBC0, 0xBCD, 0xBD7, 0xC00, 0xC04, 0xC3C, 0xC81, 0xCBC, 0xCC2, 0xD3E, 0xD4D, 0xD57, 0xD81, 0xDCA, 0xDCF, 0xDD6, 0xDDF, 0xE31, 0xEB1, 0xF35, 0xF37, 0xF39, 0xFC6, 0x1082, 0x108D, 0x109D, 0x17C6, 0x17DD, 0x180F, 0x18A9, 0x1932, 0x1A1B, 0x1A56, 0x1A60, 0x1A62, 0x1A7F, 0x1BE6, 0x1BED, 0x1CED, 0x1CF4, 0x200C, 0x2D7F, 0xA802, 0xA806, 0xA80B, 0xA82C, 0xA8FF, 0xA953, 0xA9B3, 0xA9C0, 0xA9E5, 0xAA43, 0xAA4C, 0xAA7C, 0xAAB0, 0xAAC1, 0xAAF6, 0xABE5, 0xABE8, 0xABED, 0xFB1E, 0x101FD, 0x102E0, 0x10A3F, 0x11001, 0x11070, 0x110C2, 0x11173, 0x111C0, 0x111CF, 0x1123E, 0x11241, 0x112DF, 0x1133E, 0x11340, 0x1134D, 0x11357, 0x113B8, 0x113C2, 0x113C5, 0x113D2, 0x11446, 0x1145E, 0x114B0, 0x114BA, 0x114BD, 0x115AF, 0x1163D, 0x116AB, 0x116AD, 0x1171D, 0x1171F, 0x11930, 0x11943, 0x119E0, 0x11A47, 0x11B60, 0x11B66, 0x11C3F, 0x11D3A, 0x11D47, 0x11D95, 0x11D97, 0x11F5A, 0x13440, 0x16F4F, 0x16FE4, 0x1DA75, 0x1DA84, 0x1E08F, 0x1E2AE, 0x1E6E3, 0x1E6E6, 0x1E6F5); +set.addRange(0x300, 0x36F).addRange(0x483, 0x489).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x610, 0x61A).addRange(0x64B, 0x65F).addRange(0x6D6, 0x6DC).addRange(0x6DF, 0x6E4).addRange(0x6E7, 0x6E8).addRange(0x6EA, 0x6ED).addRange(0x730, 0x74A).addRange(0x7A6, 0x7B0).addRange(0x7EB, 0x7F3).addRange(0x816, 0x819).addRange(0x81B, 0x823).addRange(0x825, 0x827).addRange(0x829, 0x82D).addRange(0x859, 0x85B).addRange(0x897, 0x89F).addRange(0x8CA, 0x8E1).addRange(0x8E3, 0x902).addRange(0x941, 0x948).addRange(0x951, 0x957).addRange(0x962, 0x963).addRange(0x9C1, 0x9C4).addRange(0x9E2, 0x9E3).addRange(0xA01, 0xA02).addRange(0xA41, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA70, 0xA71).addRange(0xA81, 0xA82).addRange(0xAC1, 0xAC5).addRange(0xAC7, 0xAC8).addRange(0xAE2, 0xAE3).addRange(0xAFA, 0xAFF).addRange(0xB3E, 0xB3F).addRange(0xB41, 0xB44).addRange(0xB55, 0xB57).addRange(0xB62, 0xB63).addRange(0xC3E, 0xC40).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC62, 0xC63).addRange(0xCBF, 0xCC0).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCE2, 0xCE3); +set.addRange(0xD00, 0xD01).addRange(0xD3B, 0xD3C).addRange(0xD41, 0xD44).addRange(0xD62, 0xD63).addRange(0xDD2, 0xDD4).addRange(0xE34, 0xE3A).addRange(0xE47, 0xE4E).addRange(0xEB4, 0xEBC).addRange(0xEC8, 0xECE).addRange(0xF18, 0xF19).addRange(0xF71, 0xF7E).addRange(0xF80, 0xF84).addRange(0xF86, 0xF87).addRange(0xF8D, 0xF97).addRange(0xF99, 0xFBC).addRange(0x102D, 0x1030).addRange(0x1032, 0x1037).addRange(0x1039, 0x103A).addRange(0x103D, 0x103E).addRange(0x1058, 0x1059).addRange(0x105E, 0x1060).addRange(0x1071, 0x1074).addRange(0x1085, 0x1086).addRange(0x135D, 0x135F).addRange(0x1712, 0x1715).addRange(0x1732, 0x1734).addRange(0x1752, 0x1753).addRange(0x1772, 0x1773).addRange(0x17B4, 0x17B5).addRange(0x17B7, 0x17BD).addRange(0x17C9, 0x17D3).addRange(0x180B, 0x180D).addRange(0x1885, 0x1886).addRange(0x1920, 0x1922).addRange(0x1927, 0x1928).addRange(0x1939, 0x193B).addRange(0x1A17, 0x1A18).addRange(0x1A58, 0x1A5E).addRange(0x1A65, 0x1A6C).addRange(0x1A73, 0x1A7C).addRange(0x1AB0, 0x1ADD).addRange(0x1AE0, 0x1AEB).addRange(0x1B00, 0x1B03).addRange(0x1B34, 0x1B3D).addRange(0x1B42, 0x1B44).addRange(0x1B6B, 0x1B73).addRange(0x1B80, 0x1B81).addRange(0x1BA2, 0x1BA5).addRange(0x1BA8, 0x1BAD).addRange(0x1BE8, 0x1BE9).addRange(0x1BEF, 0x1BF3); +set.addRange(0x1C2C, 0x1C33).addRange(0x1C36, 0x1C37).addRange(0x1CD0, 0x1CD2).addRange(0x1CD4, 0x1CE0).addRange(0x1CE2, 0x1CE8).addRange(0x1CF8, 0x1CF9).addRange(0x1DC0, 0x1DFF).addRange(0x20D0, 0x20F0).addRange(0x2CEF, 0x2CF1).addRange(0x2DE0, 0x2DFF).addRange(0x302A, 0x302F).addRange(0x3099, 0x309A).addRange(0xA66F, 0xA672).addRange(0xA674, 0xA67D).addRange(0xA69E, 0xA69F).addRange(0xA6F0, 0xA6F1).addRange(0xA825, 0xA826).addRange(0xA8C4, 0xA8C5).addRange(0xA8E0, 0xA8F1).addRange(0xA926, 0xA92D).addRange(0xA947, 0xA951).addRange(0xA980, 0xA982).addRange(0xA9B6, 0xA9B9).addRange(0xA9BC, 0xA9BD).addRange(0xAA29, 0xAA2E).addRange(0xAA31, 0xAA32).addRange(0xAA35, 0xAA36).addRange(0xAAB2, 0xAAB4).addRange(0xAAB7, 0xAAB8).addRange(0xAABE, 0xAABF).addRange(0xAAEC, 0xAAED).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2F).addRange(0xFF9E, 0xFF9F).addRange(0x10376, 0x1037A).addRange(0x10A01, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A0F).addRange(0x10A38, 0x10A3A).addRange(0x10AE5, 0x10AE6).addRange(0x10D24, 0x10D27).addRange(0x10D69, 0x10D6D).addRange(0x10EAB, 0x10EAC).addRange(0x10EFA, 0x10EFF).addRange(0x10F46, 0x10F50).addRange(0x10F82, 0x10F85).addRange(0x11038, 0x11046).addRange(0x11073, 0x11074).addRange(0x1107F, 0x11081).addRange(0x110B3, 0x110B6).addRange(0x110B9, 0x110BA); +set.addRange(0x11100, 0x11102).addRange(0x11127, 0x1112B).addRange(0x1112D, 0x11134).addRange(0x11180, 0x11181).addRange(0x111B6, 0x111BE).addRange(0x111C9, 0x111CC).addRange(0x1122F, 0x11231).addRange(0x11234, 0x11237).addRange(0x112E3, 0x112EA).addRange(0x11300, 0x11301).addRange(0x1133B, 0x1133C).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x113BB, 0x113C0).addRange(0x113C7, 0x113C9).addRange(0x113CE, 0x113D0).addRange(0x113E1, 0x113E2).addRange(0x11438, 0x1143F).addRange(0x11442, 0x11444).addRange(0x114B3, 0x114B8).addRange(0x114BF, 0x114C0).addRange(0x114C2, 0x114C3).addRange(0x115B2, 0x115B5).addRange(0x115BC, 0x115BD).addRange(0x115BF, 0x115C0).addRange(0x115DC, 0x115DD).addRange(0x11633, 0x1163A).addRange(0x1163F, 0x11640).addRange(0x116B0, 0x116B7).addRange(0x11722, 0x11725).addRange(0x11727, 0x1172B).addRange(0x1182F, 0x11837).addRange(0x11839, 0x1183A).addRange(0x1193B, 0x1193E).addRange(0x119D4, 0x119D7).addRange(0x119DA, 0x119DB).addRange(0x11A01, 0x11A0A).addRange(0x11A33, 0x11A38).addRange(0x11A3B, 0x11A3E).addRange(0x11A51, 0x11A56).addRange(0x11A59, 0x11A5B).addRange(0x11A8A, 0x11A96).addRange(0x11A98, 0x11A99).addRange(0x11B62, 0x11B64).addRange(0x11C30, 0x11C36).addRange(0x11C38, 0x11C3D).addRange(0x11C92, 0x11CA7).addRange(0x11CAA, 0x11CB0).addRange(0x11CB2, 0x11CB3).addRange(0x11CB5, 0x11CB6).addRange(0x11D31, 0x11D36); +set.addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D45).addRange(0x11D90, 0x11D91).addRange(0x11EF3, 0x11EF4).addRange(0x11F00, 0x11F01).addRange(0x11F36, 0x11F3A).addRange(0x11F40, 0x11F42).addRange(0x13447, 0x13455).addRange(0x1611E, 0x16129).addRange(0x1612D, 0x1612F).addRange(0x16AF0, 0x16AF4).addRange(0x16B30, 0x16B36).addRange(0x16F8F, 0x16F92).addRange(0x16FF0, 0x16FF1).addRange(0x1BC9D, 0x1BC9E).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D165, 0x1D169).addRange(0x1D16D, 0x1D172).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1D242, 0x1D244).addRange(0x1DA00, 0x1DA36).addRange(0x1DA3B, 0x1DA6C).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E130, 0x1E136).addRange(0x1E2EC, 0x1E2EF).addRange(0x1E4EC, 0x1E4EF).addRange(0x1E5EE, 0x1E5EF).addRange(0x1E6EE, 0x1E6EF).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E944, 0x1E94A).addRange(0xE0020, 0xE007F).addRange(0xE0100, 0xE01EF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Hex_Digit.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Hex_Digit.js new file mode 100644 index 0000000000000000000000000000000000000000..8d8d69c047f1fe57f22ad1eba07edddb615fb902 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Hex_Digit.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x30, 0x39).addRange(0x41, 0x46).addRange(0x61, 0x66).addRange(0xFF10, 0xFF19).addRange(0xFF21, 0xFF26).addRange(0xFF41, 0xFF46); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/IDS_Binary_Operator.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/IDS_Binary_Operator.js new file mode 100644 index 0000000000000000000000000000000000000000..29a8a77c1b633a3042b2c7e2ba9b333629e63cbb --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/IDS_Binary_Operator.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x31EF); +set.addRange(0x2FF0, 0x2FF1).addRange(0x2FF4, 0x2FFD); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/IDS_Trinary_Operator.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/IDS_Trinary_Operator.js new file mode 100644 index 0000000000000000000000000000000000000000..d6bf98b8ad357cc01739eaee18bd3631b9c2e125 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/IDS_Trinary_Operator.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x2FF2, 0x2FF3); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/ID_Continue.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/ID_Continue.js new file mode 100644 index 0000000000000000000000000000000000000000..d26db94bad4dc54fbc7ecf27ea8439ae5801f1fb --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/ID_Continue.js @@ -0,0 +1,16 @@ +const set = require('regenerate')(0x5F, 0xAA, 0xB5, 0xB7, 0xBA, 0x2EC, 0x2EE, 0x37F, 0x38C, 0x559, 0x5BF, 0x5C7, 0x6FF, 0x7FA, 0x7FD, 0x9B2, 0x9D7, 0x9FC, 0x9FE, 0xA3C, 0xA51, 0xA5E, 0xAD0, 0xB71, 0xB9C, 0xBD0, 0xBD7, 0xDBD, 0xDCA, 0xDD6, 0xE84, 0xEA5, 0xEC6, 0xF00, 0xF35, 0xF37, 0xF39, 0xFC6, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x1AA7, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2054, 0x2071, 0x207F, 0x20E1, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214E, 0x2D27, 0x2D2D, 0x2D6F, 0xA82C, 0xA8FB, 0xFB3E, 0xFF3F, 0x101FD, 0x102E0, 0x10808, 0x1083C, 0x10A3F, 0x10F27, 0x110C2, 0x11176, 0x111DC, 0x11288, 0x11350, 0x11357, 0x1138B, 0x1138E, 0x113C2, 0x113C5, 0x114C7, 0x11644, 0x11909, 0x11A47, 0x11A9D, 0x11D3A, 0x11FB0, 0x1B132, 0x1B155, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1DA75, 0x1DA84, 0x1E08F, 0x1E14E, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E); +set.addRange(0x30, 0x39).addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x300, 0x374).addRange(0x376, 0x377).addRange(0x37A, 0x37D).addRange(0x386, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x483, 0x487).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x610, 0x61A).addRange(0x620, 0x669).addRange(0x66E, 0x6D3).addRange(0x6D5, 0x6DC).addRange(0x6DF, 0x6E8).addRange(0x6EA, 0x6FC).addRange(0x710, 0x74A).addRange(0x74D, 0x7B1).addRange(0x7C0, 0x7F5).addRange(0x800, 0x82D).addRange(0x840, 0x85B).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88F).addRange(0x897, 0x8E1).addRange(0x8E3, 0x963).addRange(0x966, 0x96F).addRange(0x971, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BC, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CE).addRange(0x9DC, 0x9DD); +set.addRange(0x9DF, 0x9E3).addRange(0x9E6, 0x9F1).addRange(0xA01, 0xA03).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA59, 0xA5C).addRange(0xA66, 0xA75).addRange(0xA81, 0xA83).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABC, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACD).addRange(0xAE0, 0xAE3).addRange(0xAE6, 0xAEF).addRange(0xAF9, 0xAFF).addRange(0xB01, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB3C, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4D).addRange(0xB55, 0xB57).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB63).addRange(0xB66, 0xB6F).addRange(0xB82, 0xB83).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9); +set.addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCD).addRange(0xBE6, 0xBEF).addRange(0xC00, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC3C, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC58, 0xC5A).addRange(0xC5C, 0xC5D).addRange(0xC60, 0xC63).addRange(0xC66, 0xC6F).addRange(0xC80, 0xC83).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCBC, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCDC, 0xCDE).addRange(0xCE0, 0xCE3).addRange(0xCE6, 0xCEF).addRange(0xCF1, 0xCF3).addRange(0xD00, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4E).addRange(0xD54, 0xD57).addRange(0xD5F, 0xD63).addRange(0xD66, 0xD6F).addRange(0xD7A, 0xD7F).addRange(0xD81, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDE6, 0xDEF).addRange(0xDF2, 0xDF3).addRange(0xE01, 0xE3A).addRange(0xE40, 0xE4E).addRange(0xE50, 0xE59); +set.addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEBD).addRange(0xEC0, 0xEC4).addRange(0xEC8, 0xECE).addRange(0xED0, 0xED9).addRange(0xEDC, 0xEDF).addRange(0xF18, 0xF19).addRange(0xF20, 0xF29).addRange(0xF3E, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF71, 0xF84).addRange(0xF86, 0xF97).addRange(0xF99, 0xFBC).addRange(0x1000, 0x1049).addRange(0x1050, 0x109D).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x135D, 0x135F).addRange(0x1369, 0x1371).addRange(0x1380, 0x138F).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16EE, 0x16F8).addRange(0x1700, 0x1715).addRange(0x171F, 0x1734).addRange(0x1740, 0x1753).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1772, 0x1773).addRange(0x1780, 0x17D3).addRange(0x17DC, 0x17DD); +set.addRange(0x17E0, 0x17E9).addRange(0x180B, 0x180D).addRange(0x180F, 0x1819).addRange(0x1820, 0x1878).addRange(0x1880, 0x18AA).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1920, 0x192B).addRange(0x1930, 0x193B).addRange(0x1946, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x19D0, 0x19DA).addRange(0x1A00, 0x1A1B).addRange(0x1A20, 0x1A5E).addRange(0x1A60, 0x1A7C).addRange(0x1A7F, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1AB0, 0x1ABD).addRange(0x1ABF, 0x1ADD).addRange(0x1AE0, 0x1AEB).addRange(0x1B00, 0x1B4C).addRange(0x1B50, 0x1B59).addRange(0x1B6B, 0x1B73).addRange(0x1B80, 0x1BF3).addRange(0x1C00, 0x1C37).addRange(0x1C40, 0x1C49).addRange(0x1C4D, 0x1C7D).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1CD0, 0x1CD2).addRange(0x1CD4, 0x1CFA).addRange(0x1D00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x200C, 0x200D).addRange(0x203F, 0x2040); +set.addRange(0x2090, 0x209C).addRange(0x20D0, 0x20DC).addRange(0x20E5, 0x20F0).addRange(0x210A, 0x2113).addRange(0x2118, 0x211D).addRange(0x212A, 0x2139).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2160, 0x2188).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D7F, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x2DE0, 0x2DFF).addRange(0x3005, 0x3007).addRange(0x3021, 0x302F).addRange(0x3031, 0x3035).addRange(0x3038, 0x303C).addRange(0x3041, 0x3096).addRange(0x3099, 0x309F).addRange(0x30A1, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA48C).addRange(0xA4D0, 0xA4FD).addRange(0xA500, 0xA60C).addRange(0xA610, 0xA62B).addRange(0xA640, 0xA66F).addRange(0xA674, 0xA67D).addRange(0xA67F, 0xA6F1).addRange(0xA717, 0xA71F).addRange(0xA722, 0xA788).addRange(0xA78B, 0xA7DC).addRange(0xA7F1, 0xA827).addRange(0xA840, 0xA873).addRange(0xA880, 0xA8C5).addRange(0xA8D0, 0xA8D9).addRange(0xA8E0, 0xA8F7).addRange(0xA8FD, 0xA92D); +set.addRange(0xA930, 0xA953).addRange(0xA960, 0xA97C).addRange(0xA980, 0xA9C0).addRange(0xA9CF, 0xA9D9).addRange(0xA9E0, 0xA9FE).addRange(0xAA00, 0xAA36).addRange(0xAA40, 0xAA4D).addRange(0xAA50, 0xAA59).addRange(0xAA60, 0xAA76).addRange(0xAA7A, 0xAAC2).addRange(0xAADB, 0xAADD).addRange(0xAAE0, 0xAAEF).addRange(0xAAF2, 0xAAF6).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABEA).addRange(0xABEC, 0xABED).addRange(0xABF0, 0xABF9).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1D, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFB).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2F).addRange(0xFE33, 0xFE34).addRange(0xFE4D, 0xFE4F).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF10, 0xFF19).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0xFF65, 0xFFBE).addRange(0xFFC2, 0xFFC7); +set.addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10140, 0x10174).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x10300, 0x1031F).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x1037A).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x103D1, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104A0, 0x104A9).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915).addRange(0x10920, 0x10939); +set.addRange(0x10940, 0x10959).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A00, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A38, 0x10A3A).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7).addRange(0x10AC9, 0x10AE6).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91).addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D00, 0x10D27).addRange(0x10D30, 0x10D39).addRange(0x10D40, 0x10D65).addRange(0x10D69, 0x10D6D).addRange(0x10D6F, 0x10D85).addRange(0x10E80, 0x10EA9).addRange(0x10EAB, 0x10EAC).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC7).addRange(0x10EFA, 0x10F1C).addRange(0x10F30, 0x10F50).addRange(0x10F70, 0x10F85).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11000, 0x11046).addRange(0x11066, 0x11075).addRange(0x1107F, 0x110BA).addRange(0x110D0, 0x110E8).addRange(0x110F0, 0x110F9).addRange(0x11100, 0x11134).addRange(0x11136, 0x1113F).addRange(0x11144, 0x11147).addRange(0x11150, 0x11173).addRange(0x11180, 0x111C4).addRange(0x111C9, 0x111CC).addRange(0x111CE, 0x111DA).addRange(0x11200, 0x11211).addRange(0x11213, 0x11237).addRange(0x1123E, 0x11241).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D); +set.addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112EA).addRange(0x112F0, 0x112F9).addRange(0x11300, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1133B, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x1135D, 0x11363).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x113B7, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113D3).addRange(0x113E1, 0x113E2).addRange(0x11400, 0x1144A).addRange(0x11450, 0x11459).addRange(0x1145E, 0x11461).addRange(0x11480, 0x114C5).addRange(0x114D0, 0x114D9).addRange(0x11580, 0x115B5).addRange(0x115B8, 0x115C0).addRange(0x115D8, 0x115DD).addRange(0x11600, 0x11640).addRange(0x11650, 0x11659).addRange(0x11680, 0x116B8).addRange(0x116C0, 0x116C9).addRange(0x116D0, 0x116E3).addRange(0x11700, 0x1171A).addRange(0x1171D, 0x1172B).addRange(0x11730, 0x11739).addRange(0x11740, 0x11746).addRange(0x11800, 0x1183A).addRange(0x118A0, 0x118E9).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x11943).addRange(0x11950, 0x11959).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D7); +set.addRange(0x119DA, 0x119E1).addRange(0x119E3, 0x119E4).addRange(0x11A00, 0x11A3E).addRange(0x11A50, 0x11A99).addRange(0x11AB0, 0x11AF8).addRange(0x11B60, 0x11B67).addRange(0x11BC0, 0x11BE0).addRange(0x11BF0, 0x11BF9).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C36).addRange(0x11C38, 0x11C40).addRange(0x11C50, 0x11C59).addRange(0x11C72, 0x11C8F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D47).addRange(0x11D50, 0x11D59).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D98).addRange(0x11DA0, 0x11DA9).addRange(0x11DB0, 0x11DDB).addRange(0x11DE0, 0x11DE9).addRange(0x11EE0, 0x11EF6).addRange(0x11F00, 0x11F10).addRange(0x11F12, 0x11F3A).addRange(0x11F3E, 0x11F42).addRange(0x11F50, 0x11F5A).addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13440, 0x13455).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x16139).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A60, 0x16A69).addRange(0x16A70, 0x16ABE).addRange(0x16AC0, 0x16AC9).addRange(0x16AD0, 0x16AED).addRange(0x16AF0, 0x16AF4).addRange(0x16B00, 0x16B36); +set.addRange(0x16B40, 0x16B43).addRange(0x16B50, 0x16B59).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D6C).addRange(0x16D70, 0x16D79).addRange(0x16E40, 0x16E7F).addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3).addRange(0x16F00, 0x16F4A).addRange(0x16F4F, 0x16F87).addRange(0x16F8F, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x16FE3, 0x16FE4).addRange(0x16FF0, 0x16FF6).addRange(0x17000, 0x18CD5).addRange(0x18CFF, 0x18D1E).addRange(0x18D80, 0x18DF2).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1BC9D, 0x1BC9E).addRange(0x1CCF0, 0x1CCF9).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D165, 0x1D169).addRange(0x1D16D, 0x1D172).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1D242, 0x1D244).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539); +set.addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1D7CE, 0x1D7FF).addRange(0x1DA00, 0x1DA36).addRange(0x1DA3B, 0x1DA6C).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E130, 0x1E13D).addRange(0x1E140, 0x1E149).addRange(0x1E290, 0x1E2AE).addRange(0x1E2C0, 0x1E2F9).addRange(0x1E4D0, 0x1E4F9).addRange(0x1E5D0, 0x1E5FA).addRange(0x1E6C0, 0x1E6DE).addRange(0x1E6E0, 0x1E6F5).addRange(0x1E6FE, 0x1E6FF).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E900, 0x1E94B).addRange(0x1E950, 0x1E959).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37); +set.addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1FBF0, 0x1FBF9).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479).addRange(0xE0100, 0xE01EF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/ID_Start.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/ID_Start.js new file mode 100644 index 0000000000000000000000000000000000000000..f01fab2857cdcaa2ad6a24294dd48ebbc961e017 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/ID_Start.js @@ -0,0 +1,13 @@ +const set = require('regenerate')(0xAA, 0xB5, 0xBA, 0x2EC, 0x2EE, 0x37F, 0x386, 0x38C, 0x559, 0x6D5, 0x6FF, 0x710, 0x7B1, 0x7FA, 0x81A, 0x824, 0x828, 0x93D, 0x950, 0x9B2, 0x9BD, 0x9CE, 0x9FC, 0xA5E, 0xABD, 0xAD0, 0xAF9, 0xB3D, 0xB71, 0xB83, 0xB9C, 0xBD0, 0xC3D, 0xC80, 0xCBD, 0xD3D, 0xD4E, 0xDBD, 0xE84, 0xEA5, 0xEBD, 0xEC6, 0xF00, 0x103F, 0x1061, 0x108E, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x17DC, 0x18AA, 0x1AA7, 0x1CFA, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2071, 0x207F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214E, 0x2D27, 0x2D2D, 0x2D6F, 0xA8FB, 0xA9CF, 0xAA7A, 0xAAB1, 0xAAC0, 0xAAC2, 0xFB1D, 0xFB3E, 0x10808, 0x1083C, 0x10A00, 0x10F27, 0x11075, 0x11144, 0x11147, 0x11176, 0x111DA, 0x111DC, 0x11288, 0x1133D, 0x11350, 0x1138B, 0x1138E, 0x113B7, 0x113D1, 0x113D3, 0x114C7, 0x11644, 0x116B8, 0x11909, 0x1193F, 0x11941, 0x119E1, 0x119E3, 0x11A00, 0x11A3A, 0x11A50, 0x11A9D, 0x11C40, 0x11D46, 0x11D98, 0x11F02, 0x11FB0, 0x16F50, 0x16FE3, 0x1B132, 0x1B155, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1E14E, 0x1E5F0, 0x1E94B, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E); +set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x370, 0x374).addRange(0x376, 0x377).addRange(0x37A, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x620, 0x64A).addRange(0x66E, 0x66F).addRange(0x671, 0x6D3).addRange(0x6E5, 0x6E6).addRange(0x6EE, 0x6EF).addRange(0x6FA, 0x6FC).addRange(0x712, 0x72F).addRange(0x74D, 0x7A5).addRange(0x7CA, 0x7EA).addRange(0x7F4, 0x7F5).addRange(0x800, 0x815).addRange(0x840, 0x858).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88F).addRange(0x8A0, 0x8C9).addRange(0x904, 0x939).addRange(0x958, 0x961).addRange(0x971, 0x980).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E1).addRange(0x9F0, 0x9F1).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33); +set.addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA59, 0xA5C).addRange(0xA72, 0xA74).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xAE0, 0xAE1).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB61).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xC05, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC58, 0xC5A).addRange(0xC5C, 0xC5D).addRange(0xC60, 0xC61).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCDC, 0xCDE).addRange(0xCE0, 0xCE1).addRange(0xCF1, 0xCF2).addRange(0xD04, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD3A).addRange(0xD54, 0xD56).addRange(0xD5F, 0xD61).addRange(0xD7A, 0xD7F).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB); +set.addRange(0xDC0, 0xDC6).addRange(0xE01, 0xE30).addRange(0xE32, 0xE33).addRange(0xE40, 0xE46).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEB0).addRange(0xEB2, 0xEB3).addRange(0xEC0, 0xEC4).addRange(0xEDC, 0xEDF).addRange(0xF40, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF88, 0xF8C).addRange(0x1000, 0x102A).addRange(0x1050, 0x1055).addRange(0x105A, 0x105D).addRange(0x1065, 0x1066).addRange(0x106E, 0x1070).addRange(0x1075, 0x1081).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x1380, 0x138F).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16EE, 0x16F8).addRange(0x1700, 0x1711).addRange(0x171F, 0x1731).addRange(0x1740, 0x1751).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1780, 0x17B3).addRange(0x1820, 0x1878); +set.addRange(0x1880, 0x18A8).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1950, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x1A00, 0x1A16).addRange(0x1A20, 0x1A54).addRange(0x1B05, 0x1B33).addRange(0x1B45, 0x1B4C).addRange(0x1B83, 0x1BA0).addRange(0x1BAE, 0x1BAF).addRange(0x1BBA, 0x1BE5).addRange(0x1C00, 0x1C23).addRange(0x1C4D, 0x1C4F).addRange(0x1C5A, 0x1C7D).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF6).addRange(0x1D00, 0x1DBF).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x2090, 0x209C).addRange(0x210A, 0x2113).addRange(0x2118, 0x211D).addRange(0x212A, 0x2139).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2160, 0x2188).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0x2D30, 0x2D67); +set.addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x3005, 0x3007).addRange(0x3021, 0x3029).addRange(0x3031, 0x3035).addRange(0x3038, 0x303C).addRange(0x3041, 0x3096).addRange(0x309B, 0x309F).addRange(0x30A1, 0x30FA).addRange(0x30FC, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA48C).addRange(0xA4D0, 0xA4FD).addRange(0xA500, 0xA60C).addRange(0xA610, 0xA61F).addRange(0xA62A, 0xA62B).addRange(0xA640, 0xA66E).addRange(0xA67F, 0xA69D).addRange(0xA6A0, 0xA6EF).addRange(0xA717, 0xA71F).addRange(0xA722, 0xA788).addRange(0xA78B, 0xA7DC).addRange(0xA7F1, 0xA801).addRange(0xA803, 0xA805).addRange(0xA807, 0xA80A).addRange(0xA80C, 0xA822).addRange(0xA840, 0xA873).addRange(0xA882, 0xA8B3).addRange(0xA8F2, 0xA8F7).addRange(0xA8FD, 0xA8FE).addRange(0xA90A, 0xA925).addRange(0xA930, 0xA946).addRange(0xA960, 0xA97C).addRange(0xA984, 0xA9B2).addRange(0xA9E0, 0xA9E4).addRange(0xA9E6, 0xA9EF).addRange(0xA9FA, 0xA9FE).addRange(0xAA00, 0xAA28).addRange(0xAA40, 0xAA42).addRange(0xAA44, 0xAA4B); +set.addRange(0xAA60, 0xAA76).addRange(0xAA7E, 0xAAAF).addRange(0xAAB5, 0xAAB6).addRange(0xAAB9, 0xAABD).addRange(0xAADB, 0xAADD).addRange(0xAAE0, 0xAAEA).addRange(0xAAF2, 0xAAF4).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABE2).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1F, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFB).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0xFF66, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10140, 0x10174).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0); +set.addRange(0x10300, 0x1031F).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x10375).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x103D1, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915).addRange(0x10920, 0x10939).addRange(0x10940, 0x10959).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A10, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7).addRange(0x10AC9, 0x10AE4).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91); +set.addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D00, 0x10D23).addRange(0x10D4A, 0x10D65).addRange(0x10D6F, 0x10D85).addRange(0x10E80, 0x10EA9).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC7).addRange(0x10F00, 0x10F1C).addRange(0x10F30, 0x10F45).addRange(0x10F70, 0x10F81).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11003, 0x11037).addRange(0x11071, 0x11072).addRange(0x11083, 0x110AF).addRange(0x110D0, 0x110E8).addRange(0x11103, 0x11126).addRange(0x11150, 0x11172).addRange(0x11183, 0x111B2).addRange(0x111C1, 0x111C4).addRange(0x11200, 0x11211).addRange(0x11213, 0x1122B).addRange(0x1123F, 0x11240).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112DE).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1135D, 0x11361).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x11400, 0x11434).addRange(0x11447, 0x1144A).addRange(0x1145F, 0x11461).addRange(0x11480, 0x114AF).addRange(0x114C4, 0x114C5).addRange(0x11580, 0x115AE).addRange(0x115D8, 0x115DB).addRange(0x11600, 0x1162F).addRange(0x11680, 0x116AA).addRange(0x11700, 0x1171A).addRange(0x11740, 0x11746).addRange(0x11800, 0x1182B); +set.addRange(0x118A0, 0x118DF).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x1192F).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D0).addRange(0x11A0B, 0x11A32).addRange(0x11A5C, 0x11A89).addRange(0x11AB0, 0x11AF8).addRange(0x11BC0, 0x11BE0).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C2E).addRange(0x11C72, 0x11C8F).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D30).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D89).addRange(0x11DB0, 0x11DDB).addRange(0x11EE0, 0x11EF2).addRange(0x11F04, 0x11F10).addRange(0x11F12, 0x11F33).addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13441, 0x13446).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x1611D).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A70, 0x16ABE).addRange(0x16AD0, 0x16AED).addRange(0x16B00, 0x16B2F).addRange(0x16B40, 0x16B43).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D6C).addRange(0x16E40, 0x16E7F).addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3).addRange(0x16F00, 0x16F4A).addRange(0x16F93, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x16FF2, 0x16FF6).addRange(0x17000, 0x18CD5).addRange(0x18CFF, 0x18D1E); +set.addRange(0x18D80, 0x18DF2).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E137, 0x1E13D).addRange(0x1E290, 0x1E2AD).addRange(0x1E2C0, 0x1E2EB).addRange(0x1E4D0, 0x1E4EB).addRange(0x1E5D0, 0x1E5ED).addRange(0x1E6C0, 0x1E6DE).addRange(0x1E6E0, 0x1E6E2).addRange(0x1E6E4, 0x1E6E5); +set.addRange(0x1E6E7, 0x1E6ED).addRange(0x1E6F0, 0x1E6F4).addRange(0x1E6FE, 0x1E6FF).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E900, 0x1E943).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Ideographic.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Ideographic.js new file mode 100644 index 0000000000000000000000000000000000000000..193a40d22e81289da3bf29bdf18abfcc085e9a75 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Ideographic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x16FE4); +set.addRange(0x3006, 0x3007).addRange(0x3021, 0x3029).addRange(0x3038, 0x303A).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0x9FFF).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0x16FF2, 0x16FF6).addRange(0x17000, 0x18CD5).addRange(0x18CFF, 0x18D1E).addRange(0x18D80, 0x18DF2).addRange(0x1B170, 0x1B2FB).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Join_Control.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Join_Control.js new file mode 100644 index 0000000000000000000000000000000000000000..d5fbc6a03c9f4695645f21976a350b1bc79af9b0 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Join_Control.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x200C, 0x200D); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Logical_Order_Exception.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Logical_Order_Exception.js new file mode 100644 index 0000000000000000000000000000000000000000..ef3d30a62c9d084099bf0029277a66268560ea67 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Logical_Order_Exception.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x19BA, 0xAAB9); +set.addRange(0xE40, 0xE44).addRange(0xEC0, 0xEC4).addRange(0x19B5, 0x19B7).addRange(0xAAB5, 0xAAB6).addRange(0xAABB, 0xAABC); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Lowercase.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Lowercase.js new file mode 100644 index 0000000000000000000000000000000000000000..e633490c8f9f5f936fedf20daa04414f6853e492 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Lowercase.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0xAA, 0xB5, 0xBA, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x12F, 0x131, 0x133, 0x135, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x183, 0x185, 0x188, 0x192, 0x195, 0x19E, 0x1A1, 0x1A3, 0x1A5, 0x1A8, 0x1AD, 0x1B0, 0x1B4, 0x1B6, 0x1C6, 0x1C9, 0x1CC, 0x1CE, 0x1D0, 0x1D2, 0x1D4, 0x1D6, 0x1D8, 0x1DA, 0x1DF, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x1E9, 0x1EB, 0x1ED, 0x1F3, 0x1F5, 0x1F9, 0x1FB, 0x1FD, 0x1FF, 0x201, 0x203, 0x205, 0x207, 0x209, 0x20B, 0x20D, 0x20F, 0x211, 0x213, 0x215, 0x217, 0x219, 0x21B, 0x21D, 0x21F, 0x221, 0x223, 0x225, 0x227, 0x229, 0x22B, 0x22D, 0x22F, 0x231, 0x23C, 0x242, 0x247, 0x249, 0x24B, 0x24D, 0x345, 0x371, 0x373, 0x377, 0x390, 0x3D9, 0x3DB, 0x3DD, 0x3DF, 0x3E1, 0x3E3, 0x3E5, 0x3E7, 0x3E9, 0x3EB, 0x3ED, 0x3F5, 0x3F8, 0x461, 0x463, 0x465, 0x467, 0x469, 0x46B, 0x46D, 0x46F, 0x471, 0x473, 0x475, 0x477, 0x479, 0x47B, 0x47D, 0x47F, 0x481, 0x48B, 0x48D, 0x48F, 0x491, 0x493, 0x495, 0x497, 0x499, 0x49B, 0x49D, 0x49F, 0x4A1, 0x4A3, 0x4A5, 0x4A7, 0x4A9, 0x4AB, 0x4AD, 0x4AF, 0x4B1, 0x4B3, 0x4B5, 0x4B7, 0x4B9, 0x4BB, 0x4BD, 0x4BF, 0x4C2, 0x4C4, 0x4C6, 0x4C8, 0x4CA, 0x4CC, 0x4D1, 0x4D3, 0x4D5, 0x4D7, 0x4D9, 0x4DB, 0x4DD, 0x4DF, 0x4E1, 0x4E3, 0x4E5, 0x4E7, 0x4E9, 0x4EB, 0x4ED, 0x4EF, 0x4F1, 0x4F3, 0x4F5, 0x4F7, 0x4F9, 0x4FB, 0x4FD, 0x4FF, 0x501, 0x503, 0x505, 0x507, 0x509, 0x50B, 0x50D, 0x50F, 0x511, 0x513, 0x515, 0x517, 0x519, 0x51B, 0x51D, 0x51F, 0x521, 0x523, 0x525, 0x527, 0x529, 0x52B, 0x52D, 0x52F, 0x1C8A, 0x1E01, 0x1E03, 0x1E05, 0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13, 0x1E15, 0x1E17, 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27, 0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39, 0x1E3B, 0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F, 0x1E51, 0x1E53, 0x1E55, 0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63, 0x1E65, 0x1E67, 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77, 0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89, 0x1E8B, 0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1E9F, 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9, 0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, 0x1ED1, 0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EE3, 0x1EE5, 0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9, 0x1EFB, 0x1EFD, 0x1FBE, 0x2071, 0x207F, 0x210A, 0x2113, 0x212F, 0x2134, 0x2139, 0x214E, 0x2184, 0x2C61, 0x2C68, 0x2C6A, 0x2C6C, 0x2C71, 0x2C81, 0x2C83, 0x2C85, 0x2C87, 0x2C89, 0x2C8B, 0x2C8D, 0x2C8F, 0x2C91, 0x2C93, 0x2C95, 0x2C97, 0x2C99, 0x2C9B, 0x2C9D, 0x2C9F, 0x2CA1, 0x2CA3, 0x2CA5, 0x2CA7, 0x2CA9, 0x2CAB, 0x2CAD, 0x2CAF, 0x2CB1, 0x2CB3, 0x2CB5, 0x2CB7, 0x2CB9, 0x2CBB, 0x2CBD, 0x2CBF, 0x2CC1, 0x2CC3, 0x2CC5, 0x2CC7, 0x2CC9, 0x2CCB, 0x2CCD, 0x2CCF, 0x2CD1, 0x2CD3, 0x2CD5, 0x2CD7, 0x2CD9, 0x2CDB, 0x2CDD, 0x2CDF, 0x2CE1, 0x2CEC, 0x2CEE, 0x2CF3, 0x2D27, 0x2D2D, 0xA641, 0xA643, 0xA645, 0xA647, 0xA649, 0xA64B, 0xA64D, 0xA64F, 0xA651, 0xA653, 0xA655, 0xA657, 0xA659, 0xA65B, 0xA65D, 0xA65F, 0xA661, 0xA663, 0xA665, 0xA667, 0xA669, 0xA66B, 0xA66D, 0xA681, 0xA683, 0xA685, 0xA687, 0xA689, 0xA68B, 0xA68D, 0xA68F, 0xA691, 0xA693, 0xA695, 0xA697, 0xA699, 0xA723, 0xA725, 0xA727, 0xA729, 0xA72B, 0xA72D, 0xA733, 0xA735, 0xA737, 0xA739, 0xA73B, 0xA73D, 0xA73F, 0xA741, 0xA743, 0xA745, 0xA747, 0xA749, 0xA74B, 0xA74D, 0xA74F, 0xA751, 0xA753, 0xA755, 0xA757, 0xA759, 0xA75B, 0xA75D, 0xA75F, 0xA761, 0xA763, 0xA765, 0xA767, 0xA769, 0xA76B, 0xA76D, 0xA77A, 0xA77C, 0xA77F, 0xA781, 0xA783, 0xA785, 0xA787, 0xA78C, 0xA78E, 0xA791, 0xA797, 0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3, 0xA7A5, 0xA7A7, 0xA7A9, 0xA7AF, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C1, 0xA7C3, 0xA7C8, 0xA7CA, 0xA7CD, 0xA7CF, 0xA7D1, 0xA7D3, 0xA7D5, 0xA7D7, 0xA7D9, 0xA7DB, 0xA7F6, 0x10780, 0x1D4BB, 0x1D7CB); +set.addRange(0x61, 0x7A).addRange(0xDF, 0xF6).addRange(0xF8, 0xFF).addRange(0x137, 0x138).addRange(0x148, 0x149).addRange(0x17E, 0x180).addRange(0x18C, 0x18D).addRange(0x199, 0x19B).addRange(0x1AA, 0x1AB).addRange(0x1B9, 0x1BA).addRange(0x1BD, 0x1BF).addRange(0x1DC, 0x1DD).addRange(0x1EF, 0x1F0).addRange(0x233, 0x239).addRange(0x23F, 0x240).addRange(0x24F, 0x293).addRange(0x296, 0x2B8).addRange(0x2C0, 0x2C1).addRange(0x2E0, 0x2E4).addRange(0x37A, 0x37D).addRange(0x3AC, 0x3CE).addRange(0x3D0, 0x3D1).addRange(0x3D5, 0x3D7).addRange(0x3EF, 0x3F3).addRange(0x3FB, 0x3FC).addRange(0x430, 0x45F).addRange(0x4CE, 0x4CF).addRange(0x560, 0x588).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x10FF).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C88).addRange(0x1D00, 0x1DBF).addRange(0x1E95, 0x1E9D).addRange(0x1EFF, 0x1F07).addRange(0x1F10, 0x1F15).addRange(0x1F20, 0x1F27).addRange(0x1F30, 0x1F37).addRange(0x1F40, 0x1F45).addRange(0x1F50, 0x1F57).addRange(0x1F60, 0x1F67).addRange(0x1F70, 0x1F7D).addRange(0x1F80, 0x1F87).addRange(0x1F90, 0x1F97).addRange(0x1FA0, 0x1FA7).addRange(0x1FB0, 0x1FB4).addRange(0x1FB6, 0x1FB7).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FC7).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FD7); +set.addRange(0x1FE0, 0x1FE7).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FF7).addRange(0x2090, 0x209C).addRange(0x210E, 0x210F).addRange(0x213C, 0x213D).addRange(0x2146, 0x2149).addRange(0x2170, 0x217F).addRange(0x24D0, 0x24E9).addRange(0x2C30, 0x2C5F).addRange(0x2C65, 0x2C66).addRange(0x2C73, 0x2C74).addRange(0x2C76, 0x2C7D).addRange(0x2CE3, 0x2CE4).addRange(0x2D00, 0x2D25).addRange(0xA69B, 0xA69D).addRange(0xA72F, 0xA731).addRange(0xA76F, 0xA778).addRange(0xA793, 0xA795).addRange(0xA7F1, 0xA7F4).addRange(0xA7F8, 0xA7FA).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF41, 0xFF5A).addRange(0x10428, 0x1044F).addRange(0x104D8, 0x104FB).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10783, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10CC0, 0x10CF2).addRange(0x10D70, 0x10D85).addRange(0x118C0, 0x118DF).addRange(0x16E60, 0x16E7F).addRange(0x16EBB, 0x16ED3).addRange(0x1D41A, 0x1D433).addRange(0x1D44E, 0x1D454).addRange(0x1D456, 0x1D467).addRange(0x1D482, 0x1D49B).addRange(0x1D4B6, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D4CF).addRange(0x1D4EA, 0x1D503).addRange(0x1D51E, 0x1D537).addRange(0x1D552, 0x1D56B); +set.addRange(0x1D586, 0x1D59F).addRange(0x1D5BA, 0x1D5D3).addRange(0x1D5EE, 0x1D607).addRange(0x1D622, 0x1D63B).addRange(0x1D656, 0x1D66F).addRange(0x1D68A, 0x1D6A5).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6E1).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D71B).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D755).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D78F).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7C9).addRange(0x1DF00, 0x1DF09).addRange(0x1DF0B, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E030, 0x1E06D).addRange(0x1E922, 0x1E943); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Math.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Math.js new file mode 100644 index 0000000000000000000000000000000000000000..fd3020ecd744e06260981ce51f2ff6bf48975fc5 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Math.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0x2B, 0x5E, 0x7C, 0x7E, 0xAC, 0xB1, 0xD7, 0xF7, 0x3D5, 0x2016, 0x2040, 0x2044, 0x2052, 0x20E1, 0x2102, 0x2107, 0x2115, 0x2124, 0x214B, 0x21DD, 0x237C, 0x23B7, 0x23D0, 0x25E2, 0x25E4, 0x2640, 0x2642, 0xFB29, 0xFE68, 0xFF0B, 0xFF3C, 0xFF3E, 0xFF5C, 0xFF5E, 0xFFE2, 0x1CEF0, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E); +set.addRange(0x3C, 0x3E).addRange(0x3D0, 0x3D2).addRange(0x3F0, 0x3F1).addRange(0x3F4, 0x3F6).addRange(0x606, 0x608).addRange(0x2032, 0x2034).addRange(0x2061, 0x2064).addRange(0x207A, 0x207E).addRange(0x208A, 0x208E).addRange(0x20D0, 0x20DC).addRange(0x20E5, 0x20E6).addRange(0x20EB, 0x20EF).addRange(0x210A, 0x2113).addRange(0x2118, 0x211D).addRange(0x2128, 0x2129).addRange(0x212C, 0x212D).addRange(0x212F, 0x2131).addRange(0x2133, 0x2138).addRange(0x213C, 0x2149).addRange(0x2190, 0x21A7).addRange(0x21A9, 0x21AE).addRange(0x21B0, 0x21B1).addRange(0x21B6, 0x21B7).addRange(0x21BC, 0x21DB).addRange(0x21E4, 0x21E5).addRange(0x21F4, 0x22FF).addRange(0x2308, 0x230B).addRange(0x2320, 0x2321).addRange(0x239B, 0x23B5).addRange(0x23DC, 0x23E2).addRange(0x25A0, 0x25A1).addRange(0x25AE, 0x25B7).addRange(0x25BC, 0x25C1).addRange(0x25C6, 0x25C7).addRange(0x25CA, 0x25CB).addRange(0x25CF, 0x25D3).addRange(0x25E7, 0x25EC).addRange(0x25F8, 0x25FF).addRange(0x2605, 0x2606).addRange(0x2660, 0x2663).addRange(0x266D, 0x266F).addRange(0x27C0, 0x27FF).addRange(0x2900, 0x2AFF).addRange(0x2B30, 0x2B44).addRange(0x2B47, 0x2B4C).addRange(0xFE61, 0xFE66).addRange(0xFF1C, 0xFF1E).addRange(0xFFE9, 0xFFEC).addRange(0x10D8E, 0x10D8F).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C); +set.addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D7CB).addRange(0x1D7CE, 0x1D7FF).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1EEF0, 0x1EEF1).addRange(0x1F8D0, 0x1F8D8); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Noncharacter_Code_Point.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Noncharacter_Code_Point.js new file mode 100644 index 0000000000000000000000000000000000000000..0de73b72d331582931e047770bf4e07ca587552e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Noncharacter_Code_Point.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xFDD0, 0xFDEF).addRange(0xFFFE, 0xFFFF).addRange(0x1FFFE, 0x1FFFF).addRange(0x2FFFE, 0x2FFFF).addRange(0x3FFFE, 0x3FFFF).addRange(0x4FFFE, 0x4FFFF).addRange(0x5FFFE, 0x5FFFF).addRange(0x6FFFE, 0x6FFFF).addRange(0x7FFFE, 0x7FFFF).addRange(0x8FFFE, 0x8FFFF).addRange(0x9FFFE, 0x9FFFF).addRange(0xAFFFE, 0xAFFFF).addRange(0xBFFFE, 0xBFFFF).addRange(0xCFFFE, 0xCFFFF).addRange(0xDFFFE, 0xDFFFF).addRange(0xEFFFE, 0xEFFFF).addRange(0xFFFFE, 0xFFFFF).addRange(0x10FFFE, 0x10FFFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Pattern_Syntax.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Pattern_Syntax.js new file mode 100644 index 0000000000000000000000000000000000000000..629abe32269fe47fa51398c6ec6f39ef4d76a386 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Pattern_Syntax.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x60, 0xA9, 0xAE, 0xB6, 0xBB, 0xBF, 0xD7, 0xF7, 0x3030); +set.addRange(0x21, 0x2F).addRange(0x3A, 0x40).addRange(0x5B, 0x5E).addRange(0x7B, 0x7E).addRange(0xA1, 0xA7).addRange(0xAB, 0xAC).addRange(0xB0, 0xB1).addRange(0x2010, 0x2027).addRange(0x2030, 0x203E).addRange(0x2041, 0x2053).addRange(0x2055, 0x205E).addRange(0x2190, 0x245F).addRange(0x2500, 0x2775).addRange(0x2794, 0x2BFF).addRange(0x2E00, 0x2E7F).addRange(0x3001, 0x3003).addRange(0x3008, 0x3020).addRange(0xFD3E, 0xFD3F).addRange(0xFE45, 0xFE46); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Pattern_White_Space.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Pattern_White_Space.js new file mode 100644 index 0000000000000000000000000000000000000000..24614a59e1ffabe691a0eb83ecf6f8f01a7f553f --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Pattern_White_Space.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x20, 0x85); +set.addRange(0x9, 0xD).addRange(0x200E, 0x200F).addRange(0x2028, 0x2029); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Quotation_Mark.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Quotation_Mark.js new file mode 100644 index 0000000000000000000000000000000000000000..03f56ddfd24f695db5e75bb65213c72a3e7667a3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Quotation_Mark.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x22, 0x27, 0xAB, 0xBB, 0x2E42, 0xFF02, 0xFF07); +set.addRange(0x2018, 0x201F).addRange(0x2039, 0x203A).addRange(0x300C, 0x300F).addRange(0x301D, 0x301F).addRange(0xFE41, 0xFE44).addRange(0xFF62, 0xFF63); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Radical.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Radical.js new file mode 100644 index 0000000000000000000000000000000000000000..a8f17cc2b3216007e8561b02257dadf2705eb7b0 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Radical.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Regional_Indicator.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Regional_Indicator.js new file mode 100644 index 0000000000000000000000000000000000000000..5846a36a27f62e0c6aa1556bb8d56a928056d176 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Regional_Indicator.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1F1E6, 0x1F1FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Sentence_Terminal.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Sentence_Terminal.js new file mode 100644 index 0000000000000000000000000000000000000000..814a6fdd6fa571d8c271f186fa6f790e1a40254c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Sentence_Terminal.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0x21, 0x2E, 0x3F, 0x589, 0x6D4, 0x7F9, 0x837, 0x839, 0x1362, 0x166E, 0x1803, 0x1809, 0x2024, 0x2E2E, 0x2E3C, 0x3002, 0xA4FF, 0xA6F3, 0xA6F7, 0xA92F, 0xABEB, 0xFE12, 0xFE52, 0xFF01, 0xFF0E, 0xFF1F, 0xFF61, 0x111CD, 0x112A9, 0x11944, 0x11946, 0x16AF5, 0x16B44, 0x16E98, 0x1BC9F, 0x1DA88); +set.addRange(0x61D, 0x61F).addRange(0x700, 0x702).addRange(0x83D, 0x83E).addRange(0x964, 0x965).addRange(0x104A, 0x104B).addRange(0x1367, 0x1368).addRange(0x1735, 0x1736).addRange(0x17D4, 0x17D5).addRange(0x1944, 0x1945).addRange(0x1AA8, 0x1AAB).addRange(0x1B4E, 0x1B4F).addRange(0x1B5A, 0x1B5B).addRange(0x1B5E, 0x1B5F).addRange(0x1B7D, 0x1B7F).addRange(0x1C3B, 0x1C3C).addRange(0x1C7E, 0x1C7F).addRange(0x203C, 0x203D).addRange(0x2047, 0x2049).addRange(0x2CF9, 0x2CFB).addRange(0x2E53, 0x2E54).addRange(0xA60E, 0xA60F).addRange(0xA876, 0xA877).addRange(0xA8CE, 0xA8CF).addRange(0xA9C8, 0xA9C9).addRange(0xAA5D, 0xAA5F).addRange(0xAAF0, 0xAAF1).addRange(0xFE15, 0xFE16).addRange(0xFE56, 0xFE57).addRange(0x10A56, 0x10A57).addRange(0x10F55, 0x10F59).addRange(0x10F86, 0x10F89).addRange(0x11047, 0x11048).addRange(0x110BE, 0x110C1).addRange(0x11141, 0x11143).addRange(0x111C5, 0x111C6).addRange(0x111DE, 0x111DF).addRange(0x11238, 0x11239).addRange(0x1123B, 0x1123C).addRange(0x113D4, 0x113D5).addRange(0x1144B, 0x1144C).addRange(0x115C2, 0x115C3).addRange(0x115C9, 0x115D7).addRange(0x11641, 0x11642).addRange(0x1173C, 0x1173E).addRange(0x11A42, 0x11A43).addRange(0x11A9B, 0x11A9C).addRange(0x11C41, 0x11C42).addRange(0x11EF7, 0x11EF8).addRange(0x11F43, 0x11F44).addRange(0x16A6E, 0x16A6F).addRange(0x16B37, 0x16B38); +set.addRange(0x16D6E, 0x16D6F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Soft_Dotted.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Soft_Dotted.js new file mode 100644 index 0000000000000000000000000000000000000000..bb805068b3eef5593c2e2976cb37ca37c105b19e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Soft_Dotted.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x12F, 0x249, 0x268, 0x29D, 0x2B2, 0x3F3, 0x456, 0x458, 0x1D62, 0x1D96, 0x1DA4, 0x1DA8, 0x1E2D, 0x1ECB, 0x2071, 0x2C7C, 0x1DF1A, 0x1E068); +set.addRange(0x69, 0x6A).addRange(0x2148, 0x2149).addRange(0x1D422, 0x1D423).addRange(0x1D456, 0x1D457).addRange(0x1D48A, 0x1D48B).addRange(0x1D4BE, 0x1D4BF).addRange(0x1D4F2, 0x1D4F3).addRange(0x1D526, 0x1D527).addRange(0x1D55A, 0x1D55B).addRange(0x1D58E, 0x1D58F).addRange(0x1D5C2, 0x1D5C3).addRange(0x1D5F6, 0x1D5F7).addRange(0x1D62A, 0x1D62B).addRange(0x1D65E, 0x1D65F).addRange(0x1D692, 0x1D693).addRange(0x1E04C, 0x1E04D); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Terminal_Punctuation.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Terminal_Punctuation.js new file mode 100644 index 0000000000000000000000000000000000000000..c5fadabb04735b6e089d1f3b1ac51f65d445f6bc --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Terminal_Punctuation.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0x21, 0x2C, 0x2E, 0x3F, 0x37E, 0x387, 0x589, 0x5C3, 0x60C, 0x61B, 0x6D4, 0x70C, 0x85E, 0xF08, 0x166E, 0x17DA, 0x2024, 0x2E2E, 0x2E3C, 0x2E41, 0x2E4C, 0xA92F, 0xAADF, 0xABEB, 0xFE12, 0xFF01, 0xFF0C, 0xFF0E, 0xFF1F, 0xFF61, 0xFF64, 0x1039F, 0x103D0, 0x10857, 0x1091F, 0x111CD, 0x112A9, 0x11944, 0x11946, 0x11C71, 0x16AF5, 0x16B44, 0x1BC9F); +set.addRange(0x3A, 0x3B).addRange(0x61D, 0x61F).addRange(0x700, 0x70A).addRange(0x7F8, 0x7F9).addRange(0x830, 0x835).addRange(0x837, 0x83E).addRange(0x964, 0x965).addRange(0xE5A, 0xE5B).addRange(0xF0D, 0xF12).addRange(0x104A, 0x104B).addRange(0x1361, 0x1368).addRange(0x16EB, 0x16ED).addRange(0x1735, 0x1736).addRange(0x17D4, 0x17D6).addRange(0x1802, 0x1805).addRange(0x1808, 0x1809).addRange(0x1944, 0x1945).addRange(0x1AA8, 0x1AAB).addRange(0x1B4E, 0x1B4F).addRange(0x1B5A, 0x1B5B).addRange(0x1B5D, 0x1B5F).addRange(0x1B7D, 0x1B7F).addRange(0x1C3B, 0x1C3F).addRange(0x1C7E, 0x1C7F).addRange(0x203C, 0x203D).addRange(0x2047, 0x2049).addRange(0x2CF9, 0x2CFB).addRange(0x2E4E, 0x2E4F).addRange(0x2E53, 0x2E54).addRange(0x3001, 0x3002).addRange(0xA4FE, 0xA4FF).addRange(0xA60D, 0xA60F).addRange(0xA6F3, 0xA6F7).addRange(0xA876, 0xA877).addRange(0xA8CE, 0xA8CF).addRange(0xA9C7, 0xA9C9).addRange(0xAA5D, 0xAA5F).addRange(0xAAF0, 0xAAF1).addRange(0xFE15, 0xFE16).addRange(0xFE50, 0xFE52).addRange(0xFE54, 0xFE57).addRange(0xFF1A, 0xFF1B).addRange(0x10A56, 0x10A57).addRange(0x10AF0, 0x10AF5).addRange(0x10B3A, 0x10B3F).addRange(0x10B99, 0x10B9C).addRange(0x10F55, 0x10F59).addRange(0x10F86, 0x10F89).addRange(0x11047, 0x1104D).addRange(0x110BE, 0x110C1).addRange(0x11141, 0x11143); +set.addRange(0x111C5, 0x111C6).addRange(0x111DE, 0x111DF).addRange(0x11238, 0x1123C).addRange(0x113D4, 0x113D5).addRange(0x1144B, 0x1144D).addRange(0x1145A, 0x1145B).addRange(0x115C2, 0x115C5).addRange(0x115C9, 0x115D7).addRange(0x11641, 0x11642).addRange(0x1173C, 0x1173E).addRange(0x11A42, 0x11A43).addRange(0x11A9B, 0x11A9C).addRange(0x11AA1, 0x11AA2).addRange(0x11C41, 0x11C43).addRange(0x11EF7, 0x11EF8).addRange(0x11F43, 0x11F44).addRange(0x12470, 0x12474).addRange(0x16A6E, 0x16A6F).addRange(0x16B37, 0x16B39).addRange(0x16D6E, 0x16D6F).addRange(0x16E97, 0x16E98).addRange(0x1DA87, 0x1DA8A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Unified_Ideograph.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Unified_Ideograph.js new file mode 100644 index 0000000000000000000000000000000000000000..4e0586eb51fdee147fc1dc1ef91216876ef7240f --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Unified_Ideograph.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xFA11, 0xFA1F, 0xFA21); +set.addRange(0x3400, 0x4DBF).addRange(0x4E00, 0x9FFF).addRange(0xFA0E, 0xFA0F).addRange(0xFA13, 0xFA14).addRange(0xFA23, 0xFA24).addRange(0xFA27, 0xFA29).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Uppercase.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Uppercase.js new file mode 100644 index 0000000000000000000000000000000000000000..2f1201b6410b71de3f250f507ff4c45dfc0b5c41 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Uppercase.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14A, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x17B, 0x17D, 0x184, 0x1A2, 0x1A4, 0x1A9, 0x1AC, 0x1B5, 0x1BC, 0x1C4, 0x1C7, 0x1CA, 0x1CD, 0x1CF, 0x1D1, 0x1D3, 0x1D5, 0x1D7, 0x1D9, 0x1DB, 0x1DE, 0x1E0, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x1EA, 0x1EC, 0x1EE, 0x1F1, 0x1F4, 0x1FA, 0x1FC, 0x1FE, 0x200, 0x202, 0x204, 0x206, 0x208, 0x20A, 0x20C, 0x20E, 0x210, 0x212, 0x214, 0x216, 0x218, 0x21A, 0x21C, 0x21E, 0x220, 0x222, 0x224, 0x226, 0x228, 0x22A, 0x22C, 0x22E, 0x230, 0x232, 0x241, 0x248, 0x24A, 0x24C, 0x24E, 0x370, 0x372, 0x376, 0x37F, 0x386, 0x38C, 0x3CF, 0x3D8, 0x3DA, 0x3DC, 0x3DE, 0x3E0, 0x3E2, 0x3E4, 0x3E6, 0x3E8, 0x3EA, 0x3EC, 0x3EE, 0x3F4, 0x3F7, 0x460, 0x462, 0x464, 0x466, 0x468, 0x46A, 0x46C, 0x46E, 0x470, 0x472, 0x474, 0x476, 0x478, 0x47A, 0x47C, 0x47E, 0x480, 0x48A, 0x48C, 0x48E, 0x490, 0x492, 0x494, 0x496, 0x498, 0x49A, 0x49C, 0x49E, 0x4A0, 0x4A2, 0x4A4, 0x4A6, 0x4A8, 0x4AA, 0x4AC, 0x4AE, 0x4B0, 0x4B2, 0x4B4, 0x4B6, 0x4B8, 0x4BA, 0x4BC, 0x4BE, 0x4C3, 0x4C5, 0x4C7, 0x4C9, 0x4CB, 0x4CD, 0x4D0, 0x4D2, 0x4D4, 0x4D6, 0x4D8, 0x4DA, 0x4DC, 0x4DE, 0x4E0, 0x4E2, 0x4E4, 0x4E6, 0x4E8, 0x4EA, 0x4EC, 0x4EE, 0x4F0, 0x4F2, 0x4F4, 0x4F6, 0x4F8, 0x4FA, 0x4FC, 0x4FE, 0x500, 0x502, 0x504, 0x506, 0x508, 0x50A, 0x50C, 0x50E, 0x510, 0x512, 0x514, 0x516, 0x518, 0x51A, 0x51C, 0x51E, 0x520, 0x522, 0x524, 0x526, 0x528, 0x52A, 0x52C, 0x52E, 0x10C7, 0x10CD, 0x1C89, 0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12, 0x1E14, 0x1E16, 0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26, 0x1E28, 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, 0x1E3A, 0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C, 0x1E4E, 0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62, 0x1E64, 0x1E66, 0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76, 0x1E78, 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, 0x1E8A, 0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94, 0x1E9E, 0x1EA0, 0x1EA2, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4, 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4, 0x1EF6, 0x1EF8, 0x1EFA, 0x1EFC, 0x1EFE, 0x1F59, 0x1F5B, 0x1F5D, 0x1F5F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2145, 0x2183, 0x2C60, 0x2C67, 0x2C69, 0x2C6B, 0x2C72, 0x2C75, 0x2C82, 0x2C84, 0x2C86, 0x2C88, 0x2C8A, 0x2C8C, 0x2C8E, 0x2C90, 0x2C92, 0x2C94, 0x2C96, 0x2C98, 0x2C9A, 0x2C9C, 0x2C9E, 0x2CA0, 0x2CA2, 0x2CA4, 0x2CA6, 0x2CA8, 0x2CAA, 0x2CAC, 0x2CAE, 0x2CB0, 0x2CB2, 0x2CB4, 0x2CB6, 0x2CB8, 0x2CBA, 0x2CBC, 0x2CBE, 0x2CC0, 0x2CC2, 0x2CC4, 0x2CC6, 0x2CC8, 0x2CCA, 0x2CCC, 0x2CCE, 0x2CD0, 0x2CD2, 0x2CD4, 0x2CD6, 0x2CD8, 0x2CDA, 0x2CDC, 0x2CDE, 0x2CE0, 0x2CE2, 0x2CEB, 0x2CED, 0x2CF2, 0xA640, 0xA642, 0xA644, 0xA646, 0xA648, 0xA64A, 0xA64C, 0xA64E, 0xA650, 0xA652, 0xA654, 0xA656, 0xA658, 0xA65A, 0xA65C, 0xA65E, 0xA660, 0xA662, 0xA664, 0xA666, 0xA668, 0xA66A, 0xA66C, 0xA680, 0xA682, 0xA684, 0xA686, 0xA688, 0xA68A, 0xA68C, 0xA68E, 0xA690, 0xA692, 0xA694, 0xA696, 0xA698, 0xA69A, 0xA722, 0xA724, 0xA726, 0xA728, 0xA72A, 0xA72C, 0xA72E, 0xA732, 0xA734, 0xA736, 0xA738, 0xA73A, 0xA73C, 0xA73E, 0xA740, 0xA742, 0xA744, 0xA746, 0xA748, 0xA74A, 0xA74C, 0xA74E, 0xA750, 0xA752, 0xA754, 0xA756, 0xA758, 0xA75A, 0xA75C, 0xA75E, 0xA760, 0xA762, 0xA764, 0xA766, 0xA768, 0xA76A, 0xA76C, 0xA76E, 0xA779, 0xA77B, 0xA780, 0xA782, 0xA784, 0xA786, 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798, 0xA79A, 0xA79C, 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7B6, 0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C9, 0xA7CE, 0xA7D0, 0xA7D2, 0xA7D4, 0xA7D6, 0xA7D8, 0xA7DA, 0xA7DC, 0xA7F5, 0x1D49C, 0x1D4A2, 0x1D546, 0x1D7CA); +set.addRange(0x41, 0x5A).addRange(0xC0, 0xD6).addRange(0xD8, 0xDE).addRange(0x178, 0x179).addRange(0x181, 0x182).addRange(0x186, 0x187).addRange(0x189, 0x18B).addRange(0x18E, 0x191).addRange(0x193, 0x194).addRange(0x196, 0x198).addRange(0x19C, 0x19D).addRange(0x19F, 0x1A0).addRange(0x1A6, 0x1A7).addRange(0x1AE, 0x1AF).addRange(0x1B1, 0x1B3).addRange(0x1B7, 0x1B8).addRange(0x1F6, 0x1F8).addRange(0x23A, 0x23B).addRange(0x23D, 0x23E).addRange(0x243, 0x246).addRange(0x388, 0x38A).addRange(0x38E, 0x38F).addRange(0x391, 0x3A1).addRange(0x3A3, 0x3AB).addRange(0x3D2, 0x3D4).addRange(0x3F9, 0x3FA).addRange(0x3FD, 0x42F).addRange(0x4C0, 0x4C1).addRange(0x531, 0x556).addRange(0x10A0, 0x10C5).addRange(0x13A0, 0x13F5).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1F08, 0x1F0F).addRange(0x1F18, 0x1F1D).addRange(0x1F28, 0x1F2F).addRange(0x1F38, 0x1F3F).addRange(0x1F48, 0x1F4D).addRange(0x1F68, 0x1F6F).addRange(0x1FB8, 0x1FBB).addRange(0x1FC8, 0x1FCB).addRange(0x1FD8, 0x1FDB).addRange(0x1FE8, 0x1FEC).addRange(0x1FF8, 0x1FFB).addRange(0x210B, 0x210D).addRange(0x2110, 0x2112).addRange(0x2119, 0x211D).addRange(0x212A, 0x212D).addRange(0x2130, 0x2133).addRange(0x213E, 0x213F).addRange(0x2160, 0x216F); +set.addRange(0x24B6, 0x24CF).addRange(0x2C00, 0x2C2F).addRange(0x2C62, 0x2C64).addRange(0x2C6D, 0x2C70).addRange(0x2C7E, 0x2C80).addRange(0xA77D, 0xA77E).addRange(0xA7AA, 0xA7AE).addRange(0xA7B0, 0xA7B4).addRange(0xA7C4, 0xA7C7).addRange(0xA7CB, 0xA7CC).addRange(0xFF21, 0xFF3A).addRange(0x10400, 0x10427).addRange(0x104B0, 0x104D3).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10C80, 0x10CB2).addRange(0x10D50, 0x10D65).addRange(0x118A0, 0x118BF).addRange(0x16E40, 0x16E5F).addRange(0x16EA0, 0x16EB8).addRange(0x1D400, 0x1D419).addRange(0x1D434, 0x1D44D).addRange(0x1D468, 0x1D481).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B5).addRange(0x1D4D0, 0x1D4E9).addRange(0x1D504, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D538, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D56C, 0x1D585).addRange(0x1D5A0, 0x1D5B9).addRange(0x1D5D4, 0x1D5ED).addRange(0x1D608, 0x1D621).addRange(0x1D63C, 0x1D655).addRange(0x1D670, 0x1D689).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6E2, 0x1D6FA).addRange(0x1D71C, 0x1D734).addRange(0x1D756, 0x1D76E).addRange(0x1D790, 0x1D7A8).addRange(0x1E900, 0x1E921).addRange(0x1F130, 0x1F149); +set.addRange(0x1F150, 0x1F169).addRange(0x1F170, 0x1F189); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Variation_Selector.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Variation_Selector.js new file mode 100644 index 0000000000000000000000000000000000000000..b5cd6138cf1f5fe864ce7f67c53d9ac3dea428ef --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/Variation_Selector.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x180F); +set.addRange(0x180B, 0x180D).addRange(0xFE00, 0xFE0F).addRange(0xE0100, 0xE01EF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/White_Space.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/White_Space.js new file mode 100644 index 0000000000000000000000000000000000000000..5e7105c742d4e03f5cd53b3f79ec9e375089004b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/White_Space.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x20, 0x85, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000); +set.addRange(0x9, 0xD).addRange(0x2000, 0x200A).addRange(0x2028, 0x2029); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/XID_Continue.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/XID_Continue.js new file mode 100644 index 0000000000000000000000000000000000000000..66ac6c7014c2cedfedd45d367604919c13767c80 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/XID_Continue.js @@ -0,0 +1,16 @@ +const set = require('regenerate')(0x5F, 0xAA, 0xB5, 0xB7, 0xBA, 0x2EC, 0x2EE, 0x37F, 0x38C, 0x559, 0x5BF, 0x5C7, 0x6FF, 0x7FA, 0x7FD, 0x9B2, 0x9D7, 0x9FC, 0x9FE, 0xA3C, 0xA51, 0xA5E, 0xAD0, 0xB71, 0xB9C, 0xBD0, 0xBD7, 0xDBD, 0xDCA, 0xDD6, 0xE84, 0xEA5, 0xEC6, 0xF00, 0xF35, 0xF37, 0xF39, 0xFC6, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x1AA7, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2054, 0x2071, 0x207F, 0x20E1, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214E, 0x2D27, 0x2D2D, 0x2D6F, 0xA82C, 0xA8FB, 0xFB3E, 0xFE71, 0xFE73, 0xFE77, 0xFE79, 0xFE7B, 0xFE7D, 0xFF3F, 0x101FD, 0x102E0, 0x10808, 0x1083C, 0x10A3F, 0x10F27, 0x110C2, 0x11176, 0x111DC, 0x11288, 0x11350, 0x11357, 0x1138B, 0x1138E, 0x113C2, 0x113C5, 0x114C7, 0x11644, 0x11909, 0x11A47, 0x11A9D, 0x11D3A, 0x11FB0, 0x1B132, 0x1B155, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1DA75, 0x1DA84, 0x1E08F, 0x1E14E, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E); +set.addRange(0x30, 0x39).addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x300, 0x374).addRange(0x376, 0x377).addRange(0x37B, 0x37D).addRange(0x386, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x483, 0x487).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x610, 0x61A).addRange(0x620, 0x669).addRange(0x66E, 0x6D3).addRange(0x6D5, 0x6DC).addRange(0x6DF, 0x6E8).addRange(0x6EA, 0x6FC).addRange(0x710, 0x74A).addRange(0x74D, 0x7B1).addRange(0x7C0, 0x7F5).addRange(0x800, 0x82D).addRange(0x840, 0x85B).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88F).addRange(0x897, 0x8E1).addRange(0x8E3, 0x963).addRange(0x966, 0x96F).addRange(0x971, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BC, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CE).addRange(0x9DC, 0x9DD); +set.addRange(0x9DF, 0x9E3).addRange(0x9E6, 0x9F1).addRange(0xA01, 0xA03).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA59, 0xA5C).addRange(0xA66, 0xA75).addRange(0xA81, 0xA83).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABC, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACD).addRange(0xAE0, 0xAE3).addRange(0xAE6, 0xAEF).addRange(0xAF9, 0xAFF).addRange(0xB01, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB3C, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4D).addRange(0xB55, 0xB57).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB63).addRange(0xB66, 0xB6F).addRange(0xB82, 0xB83).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9); +set.addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCD).addRange(0xBE6, 0xBEF).addRange(0xC00, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC3C, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC58, 0xC5A).addRange(0xC5C, 0xC5D).addRange(0xC60, 0xC63).addRange(0xC66, 0xC6F).addRange(0xC80, 0xC83).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCBC, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCDC, 0xCDE).addRange(0xCE0, 0xCE3).addRange(0xCE6, 0xCEF).addRange(0xCF1, 0xCF3).addRange(0xD00, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4E).addRange(0xD54, 0xD57).addRange(0xD5F, 0xD63).addRange(0xD66, 0xD6F).addRange(0xD7A, 0xD7F).addRange(0xD81, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDE6, 0xDEF).addRange(0xDF2, 0xDF3).addRange(0xE01, 0xE3A).addRange(0xE40, 0xE4E).addRange(0xE50, 0xE59); +set.addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEBD).addRange(0xEC0, 0xEC4).addRange(0xEC8, 0xECE).addRange(0xED0, 0xED9).addRange(0xEDC, 0xEDF).addRange(0xF18, 0xF19).addRange(0xF20, 0xF29).addRange(0xF3E, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF71, 0xF84).addRange(0xF86, 0xF97).addRange(0xF99, 0xFBC).addRange(0x1000, 0x1049).addRange(0x1050, 0x109D).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x135D, 0x135F).addRange(0x1369, 0x1371).addRange(0x1380, 0x138F).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16EE, 0x16F8).addRange(0x1700, 0x1715).addRange(0x171F, 0x1734).addRange(0x1740, 0x1753).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1772, 0x1773).addRange(0x1780, 0x17D3).addRange(0x17DC, 0x17DD); +set.addRange(0x17E0, 0x17E9).addRange(0x180B, 0x180D).addRange(0x180F, 0x1819).addRange(0x1820, 0x1878).addRange(0x1880, 0x18AA).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1920, 0x192B).addRange(0x1930, 0x193B).addRange(0x1946, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x19D0, 0x19DA).addRange(0x1A00, 0x1A1B).addRange(0x1A20, 0x1A5E).addRange(0x1A60, 0x1A7C).addRange(0x1A7F, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1AB0, 0x1ABD).addRange(0x1ABF, 0x1ADD).addRange(0x1AE0, 0x1AEB).addRange(0x1B00, 0x1B4C).addRange(0x1B50, 0x1B59).addRange(0x1B6B, 0x1B73).addRange(0x1B80, 0x1BF3).addRange(0x1C00, 0x1C37).addRange(0x1C40, 0x1C49).addRange(0x1C4D, 0x1C7D).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1CD0, 0x1CD2).addRange(0x1CD4, 0x1CFA).addRange(0x1D00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x200C, 0x200D).addRange(0x203F, 0x2040); +set.addRange(0x2090, 0x209C).addRange(0x20D0, 0x20DC).addRange(0x20E5, 0x20F0).addRange(0x210A, 0x2113).addRange(0x2118, 0x211D).addRange(0x212A, 0x2139).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2160, 0x2188).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D7F, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x2DE0, 0x2DFF).addRange(0x3005, 0x3007).addRange(0x3021, 0x302F).addRange(0x3031, 0x3035).addRange(0x3038, 0x303C).addRange(0x3041, 0x3096).addRange(0x3099, 0x309A).addRange(0x309D, 0x309F).addRange(0x30A1, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA48C).addRange(0xA4D0, 0xA4FD).addRange(0xA500, 0xA60C).addRange(0xA610, 0xA62B).addRange(0xA640, 0xA66F).addRange(0xA674, 0xA67D).addRange(0xA67F, 0xA6F1).addRange(0xA717, 0xA71F).addRange(0xA722, 0xA788).addRange(0xA78B, 0xA7DC).addRange(0xA7F1, 0xA827).addRange(0xA840, 0xA873).addRange(0xA880, 0xA8C5).addRange(0xA8D0, 0xA8D9).addRange(0xA8E0, 0xA8F7); +set.addRange(0xA8FD, 0xA92D).addRange(0xA930, 0xA953).addRange(0xA960, 0xA97C).addRange(0xA980, 0xA9C0).addRange(0xA9CF, 0xA9D9).addRange(0xA9E0, 0xA9FE).addRange(0xAA00, 0xAA36).addRange(0xAA40, 0xAA4D).addRange(0xAA50, 0xAA59).addRange(0xAA60, 0xAA76).addRange(0xAA7A, 0xAAC2).addRange(0xAADB, 0xAADD).addRange(0xAAE0, 0xAAEF).addRange(0xAAF2, 0xAAF6).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABEA).addRange(0xABEC, 0xABED).addRange(0xABF0, 0xABF9).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1D, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFC5D).addRange(0xFC64, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDF9).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2F).addRange(0xFE33, 0xFE34).addRange(0xFE4D, 0xFE4F).addRange(0xFE7F, 0xFEFC).addRange(0xFF10, 0xFF19).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0xFF65, 0xFFBE); +set.addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10140, 0x10174).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x10300, 0x1031F).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x1037A).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x103D1, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104A0, 0x104A9).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915); +set.addRange(0x10920, 0x10939).addRange(0x10940, 0x10959).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A00, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A38, 0x10A3A).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7).addRange(0x10AC9, 0x10AE6).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91).addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D00, 0x10D27).addRange(0x10D30, 0x10D39).addRange(0x10D40, 0x10D65).addRange(0x10D69, 0x10D6D).addRange(0x10D6F, 0x10D85).addRange(0x10E80, 0x10EA9).addRange(0x10EAB, 0x10EAC).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC7).addRange(0x10EFA, 0x10F1C).addRange(0x10F30, 0x10F50).addRange(0x10F70, 0x10F85).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11000, 0x11046).addRange(0x11066, 0x11075).addRange(0x1107F, 0x110BA).addRange(0x110D0, 0x110E8).addRange(0x110F0, 0x110F9).addRange(0x11100, 0x11134).addRange(0x11136, 0x1113F).addRange(0x11144, 0x11147).addRange(0x11150, 0x11173).addRange(0x11180, 0x111C4).addRange(0x111C9, 0x111CC).addRange(0x111CE, 0x111DA).addRange(0x11200, 0x11211).addRange(0x11213, 0x11237).addRange(0x1123E, 0x11241).addRange(0x11280, 0x11286); +set.addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112EA).addRange(0x112F0, 0x112F9).addRange(0x11300, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1133B, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x1135D, 0x11363).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x113B7, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113D3).addRange(0x113E1, 0x113E2).addRange(0x11400, 0x1144A).addRange(0x11450, 0x11459).addRange(0x1145E, 0x11461).addRange(0x11480, 0x114C5).addRange(0x114D0, 0x114D9).addRange(0x11580, 0x115B5).addRange(0x115B8, 0x115C0).addRange(0x115D8, 0x115DD).addRange(0x11600, 0x11640).addRange(0x11650, 0x11659).addRange(0x11680, 0x116B8).addRange(0x116C0, 0x116C9).addRange(0x116D0, 0x116E3).addRange(0x11700, 0x1171A).addRange(0x1171D, 0x1172B).addRange(0x11730, 0x11739).addRange(0x11740, 0x11746).addRange(0x11800, 0x1183A).addRange(0x118A0, 0x118E9).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x11943).addRange(0x11950, 0x11959).addRange(0x119A0, 0x119A7); +set.addRange(0x119AA, 0x119D7).addRange(0x119DA, 0x119E1).addRange(0x119E3, 0x119E4).addRange(0x11A00, 0x11A3E).addRange(0x11A50, 0x11A99).addRange(0x11AB0, 0x11AF8).addRange(0x11B60, 0x11B67).addRange(0x11BC0, 0x11BE0).addRange(0x11BF0, 0x11BF9).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C36).addRange(0x11C38, 0x11C40).addRange(0x11C50, 0x11C59).addRange(0x11C72, 0x11C8F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D47).addRange(0x11D50, 0x11D59).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D98).addRange(0x11DA0, 0x11DA9).addRange(0x11DB0, 0x11DDB).addRange(0x11DE0, 0x11DE9).addRange(0x11EE0, 0x11EF6).addRange(0x11F00, 0x11F10).addRange(0x11F12, 0x11F3A).addRange(0x11F3E, 0x11F42).addRange(0x11F50, 0x11F5A).addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13440, 0x13455).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x16139).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A60, 0x16A69).addRange(0x16A70, 0x16ABE).addRange(0x16AC0, 0x16AC9).addRange(0x16AD0, 0x16AED).addRange(0x16AF0, 0x16AF4); +set.addRange(0x16B00, 0x16B36).addRange(0x16B40, 0x16B43).addRange(0x16B50, 0x16B59).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D6C).addRange(0x16D70, 0x16D79).addRange(0x16E40, 0x16E7F).addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3).addRange(0x16F00, 0x16F4A).addRange(0x16F4F, 0x16F87).addRange(0x16F8F, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x16FE3, 0x16FE4).addRange(0x16FF0, 0x16FF6).addRange(0x17000, 0x18CD5).addRange(0x18CFF, 0x18D1E).addRange(0x18D80, 0x18DF2).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1BC9D, 0x1BC9E).addRange(0x1CCF0, 0x1CCF9).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D165, 0x1D169).addRange(0x1D16D, 0x1D172).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1D242, 0x1D244).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C); +set.addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1D7CE, 0x1D7FF).addRange(0x1DA00, 0x1DA36).addRange(0x1DA3B, 0x1DA6C).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E130, 0x1E13D).addRange(0x1E140, 0x1E149).addRange(0x1E290, 0x1E2AE).addRange(0x1E2C0, 0x1E2F9).addRange(0x1E4D0, 0x1E4F9).addRange(0x1E5D0, 0x1E5FA).addRange(0x1E6C0, 0x1E6DE).addRange(0x1E6E0, 0x1E6F5).addRange(0x1E6FE, 0x1E6FF).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E900, 0x1E94B).addRange(0x1E950, 0x1E959).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32); +set.addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1FBF0, 0x1FBF9).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479).addRange(0xE0100, 0xE01EF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/XID_Start.js b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/XID_Start.js new file mode 100644 index 0000000000000000000000000000000000000000..23dfa271213ebd28e234697e1450059516316b69 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Binary_Property/XID_Start.js @@ -0,0 +1,13 @@ +const set = require('regenerate')(0xAA, 0xB5, 0xBA, 0x2EC, 0x2EE, 0x37F, 0x386, 0x38C, 0x559, 0x6D5, 0x6FF, 0x710, 0x7B1, 0x7FA, 0x81A, 0x824, 0x828, 0x93D, 0x950, 0x9B2, 0x9BD, 0x9CE, 0x9FC, 0xA5E, 0xABD, 0xAD0, 0xAF9, 0xB3D, 0xB71, 0xB83, 0xB9C, 0xBD0, 0xC3D, 0xC80, 0xCBD, 0xD3D, 0xD4E, 0xDBD, 0xE32, 0xE84, 0xEA5, 0xEB2, 0xEBD, 0xEC6, 0xF00, 0x103F, 0x1061, 0x108E, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x17DC, 0x18AA, 0x1AA7, 0x1CFA, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2071, 0x207F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214E, 0x2D27, 0x2D2D, 0x2D6F, 0xA8FB, 0xA9CF, 0xAA7A, 0xAAB1, 0xAAC0, 0xAAC2, 0xFB1D, 0xFB3E, 0xFE71, 0xFE73, 0xFE77, 0xFE79, 0xFE7B, 0xFE7D, 0x10808, 0x1083C, 0x10A00, 0x10F27, 0x11075, 0x11144, 0x11147, 0x11176, 0x111DA, 0x111DC, 0x11288, 0x1133D, 0x11350, 0x1138B, 0x1138E, 0x113B7, 0x113D1, 0x113D3, 0x114C7, 0x11644, 0x116B8, 0x11909, 0x1193F, 0x11941, 0x119E1, 0x119E3, 0x11A00, 0x11A3A, 0x11A50, 0x11A9D, 0x11C40, 0x11D46, 0x11D98, 0x11F02, 0x11FB0, 0x16F50, 0x16FE3, 0x1B132, 0x1B155, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1E14E, 0x1E5F0, 0x1E94B, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E); +set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x370, 0x374).addRange(0x376, 0x377).addRange(0x37B, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x620, 0x64A).addRange(0x66E, 0x66F).addRange(0x671, 0x6D3).addRange(0x6E5, 0x6E6).addRange(0x6EE, 0x6EF).addRange(0x6FA, 0x6FC).addRange(0x712, 0x72F).addRange(0x74D, 0x7A5).addRange(0x7CA, 0x7EA).addRange(0x7F4, 0x7F5).addRange(0x800, 0x815).addRange(0x840, 0x858).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88F).addRange(0x8A0, 0x8C9).addRange(0x904, 0x939).addRange(0x958, 0x961).addRange(0x971, 0x980).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E1).addRange(0x9F0, 0x9F1).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33); +set.addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA59, 0xA5C).addRange(0xA72, 0xA74).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xAE0, 0xAE1).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB61).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xC05, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC58, 0xC5A).addRange(0xC5C, 0xC5D).addRange(0xC60, 0xC61).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCDC, 0xCDE).addRange(0xCE0, 0xCE1).addRange(0xCF1, 0xCF2).addRange(0xD04, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD3A).addRange(0xD54, 0xD56).addRange(0xD5F, 0xD61).addRange(0xD7A, 0xD7F).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB); +set.addRange(0xDC0, 0xDC6).addRange(0xE01, 0xE30).addRange(0xE40, 0xE46).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEB0).addRange(0xEC0, 0xEC4).addRange(0xEDC, 0xEDF).addRange(0xF40, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF88, 0xF8C).addRange(0x1000, 0x102A).addRange(0x1050, 0x1055).addRange(0x105A, 0x105D).addRange(0x1065, 0x1066).addRange(0x106E, 0x1070).addRange(0x1075, 0x1081).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x1380, 0x138F).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16EE, 0x16F8).addRange(0x1700, 0x1711).addRange(0x171F, 0x1731).addRange(0x1740, 0x1751).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1780, 0x17B3).addRange(0x1820, 0x1878).addRange(0x1880, 0x18A8).addRange(0x18B0, 0x18F5); +set.addRange(0x1900, 0x191E).addRange(0x1950, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x1A00, 0x1A16).addRange(0x1A20, 0x1A54).addRange(0x1B05, 0x1B33).addRange(0x1B45, 0x1B4C).addRange(0x1B83, 0x1BA0).addRange(0x1BAE, 0x1BAF).addRange(0x1BBA, 0x1BE5).addRange(0x1C00, 0x1C23).addRange(0x1C4D, 0x1C4F).addRange(0x1C5A, 0x1C7D).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF6).addRange(0x1D00, 0x1DBF).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x2090, 0x209C).addRange(0x210A, 0x2113).addRange(0x2118, 0x211D).addRange(0x212A, 0x2139).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2160, 0x2188).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6); +set.addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x3005, 0x3007).addRange(0x3021, 0x3029).addRange(0x3031, 0x3035).addRange(0x3038, 0x303C).addRange(0x3041, 0x3096).addRange(0x309D, 0x309F).addRange(0x30A1, 0x30FA).addRange(0x30FC, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA48C).addRange(0xA4D0, 0xA4FD).addRange(0xA500, 0xA60C).addRange(0xA610, 0xA61F).addRange(0xA62A, 0xA62B).addRange(0xA640, 0xA66E).addRange(0xA67F, 0xA69D).addRange(0xA6A0, 0xA6EF).addRange(0xA717, 0xA71F).addRange(0xA722, 0xA788).addRange(0xA78B, 0xA7DC).addRange(0xA7F1, 0xA801).addRange(0xA803, 0xA805).addRange(0xA807, 0xA80A).addRange(0xA80C, 0xA822).addRange(0xA840, 0xA873).addRange(0xA882, 0xA8B3).addRange(0xA8F2, 0xA8F7).addRange(0xA8FD, 0xA8FE).addRange(0xA90A, 0xA925).addRange(0xA930, 0xA946).addRange(0xA960, 0xA97C).addRange(0xA984, 0xA9B2).addRange(0xA9E0, 0xA9E4).addRange(0xA9E6, 0xA9EF).addRange(0xA9FA, 0xA9FE).addRange(0xAA00, 0xAA28).addRange(0xAA40, 0xAA42).addRange(0xAA44, 0xAA4B).addRange(0xAA60, 0xAA76).addRange(0xAA7E, 0xAAAF); +set.addRange(0xAAB5, 0xAAB6).addRange(0xAAB9, 0xAABD).addRange(0xAADB, 0xAADD).addRange(0xAAE0, 0xAAEA).addRange(0xAAF2, 0xAAF4).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABE2).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1F, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFC5D).addRange(0xFC64, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDF9).addRange(0xFE7F, 0xFEFC).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0xFF66, 0xFF9D).addRange(0xFFA0, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10140, 0x10174).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x10300, 0x1031F); +set.addRange(0x1032D, 0x1034A).addRange(0x10350, 0x10375).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x103D1, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915).addRange(0x10920, 0x10939).addRange(0x10940, 0x10959).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A10, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7).addRange(0x10AC9, 0x10AE4).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91).addRange(0x10C00, 0x10C48); +set.addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D00, 0x10D23).addRange(0x10D4A, 0x10D65).addRange(0x10D6F, 0x10D85).addRange(0x10E80, 0x10EA9).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC7).addRange(0x10F00, 0x10F1C).addRange(0x10F30, 0x10F45).addRange(0x10F70, 0x10F81).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11003, 0x11037).addRange(0x11071, 0x11072).addRange(0x11083, 0x110AF).addRange(0x110D0, 0x110E8).addRange(0x11103, 0x11126).addRange(0x11150, 0x11172).addRange(0x11183, 0x111B2).addRange(0x111C1, 0x111C4).addRange(0x11200, 0x11211).addRange(0x11213, 0x1122B).addRange(0x1123F, 0x11240).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112DE).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1135D, 0x11361).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x11400, 0x11434).addRange(0x11447, 0x1144A).addRange(0x1145F, 0x11461).addRange(0x11480, 0x114AF).addRange(0x114C4, 0x114C5).addRange(0x11580, 0x115AE).addRange(0x115D8, 0x115DB).addRange(0x11600, 0x1162F).addRange(0x11680, 0x116AA).addRange(0x11700, 0x1171A).addRange(0x11740, 0x11746).addRange(0x11800, 0x1182B).addRange(0x118A0, 0x118DF); +set.addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x1192F).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D0).addRange(0x11A0B, 0x11A32).addRange(0x11A5C, 0x11A89).addRange(0x11AB0, 0x11AF8).addRange(0x11BC0, 0x11BE0).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C2E).addRange(0x11C72, 0x11C8F).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D30).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D89).addRange(0x11DB0, 0x11DDB).addRange(0x11EE0, 0x11EF2).addRange(0x11F04, 0x11F10).addRange(0x11F12, 0x11F33).addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13441, 0x13446).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x1611D).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A70, 0x16ABE).addRange(0x16AD0, 0x16AED).addRange(0x16B00, 0x16B2F).addRange(0x16B40, 0x16B43).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D6C).addRange(0x16E40, 0x16E7F).addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3).addRange(0x16F00, 0x16F4A).addRange(0x16F93, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x16FF2, 0x16FF6).addRange(0x17000, 0x18CD5).addRange(0x18CFF, 0x18D1E).addRange(0x18D80, 0x18DF2); +set.addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E137, 0x1E13D).addRange(0x1E290, 0x1E2AD).addRange(0x1E2C0, 0x1E2EB).addRange(0x1E4D0, 0x1E4EB).addRange(0x1E5D0, 0x1E5ED).addRange(0x1E6C0, 0x1E6DE).addRange(0x1E6E0, 0x1E6E2).addRange(0x1E6E4, 0x1E6E5).addRange(0x1E6E7, 0x1E6ED); +set.addRange(0x1E6F0, 0x1E6F4).addRange(0x1E6FE, 0x1E6FF).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E900, 0x1E943).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Cased_Letter.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Cased_Letter.js new file mode 100644 index 0000000000000000000000000000000000000000..129a911cb43c133016298a86917dfe801562e7dd --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Cased_Letter.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0xB5, 0x37F, 0x386, 0x38C, 0x10C7, 0x10CD, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2139, 0x214E, 0x2D27, 0x2D2D, 0xA7FA, 0x1D4A2, 0x1D4BB, 0x1D546); +set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x1BA).addRange(0x1BC, 0x1BF).addRange(0x1C4, 0x293).addRange(0x296, 0x2AF).addRange(0x370, 0x373).addRange(0x376, 0x377).addRange(0x37B, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FD, 0x10FF).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1D00, 0x1D2B).addRange(0x1D6B, 0x1D77).addRange(0x1D79, 0x1D9A).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x210A, 0x2113).addRange(0x2119, 0x211D).addRange(0x212A, 0x212D).addRange(0x212F, 0x2134).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2183, 0x2184); +set.addRange(0x2C00, 0x2C7B).addRange(0x2C7E, 0x2CE4).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0xA640, 0xA66D).addRange(0xA680, 0xA69B).addRange(0xA722, 0xA76F).addRange(0xA771, 0xA787).addRange(0xA78B, 0xA78E).addRange(0xA790, 0xA7DC).addRange(0xA7F5, 0xA7F6).addRange(0xAB30, 0xAB5A).addRange(0xAB60, 0xAB68).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0x10400, 0x1044F).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D50, 0x10D65).addRange(0x10D70, 0x10D85).addRange(0x118A0, 0x118DF).addRange(0x16E40, 0x16E7F).addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E); +set.addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1DF00, 0x1DF09).addRange(0x1DF0B, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E900, 0x1E943); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Close_Punctuation.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Close_Punctuation.js new file mode 100644 index 0000000000000000000000000000000000000000..e8c3c9a77eb939248e8846e36884395389a94957 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Close_Punctuation.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x29, 0x5D, 0x7D, 0xF3B, 0xF3D, 0x169C, 0x2046, 0x207E, 0x208E, 0x2309, 0x230B, 0x232A, 0x2769, 0x276B, 0x276D, 0x276F, 0x2771, 0x2773, 0x2775, 0x27C6, 0x27E7, 0x27E9, 0x27EB, 0x27ED, 0x27EF, 0x2984, 0x2986, 0x2988, 0x298A, 0x298C, 0x298E, 0x2990, 0x2992, 0x2994, 0x2996, 0x2998, 0x29D9, 0x29DB, 0x29FD, 0x2E23, 0x2E25, 0x2E27, 0x2E29, 0x2E56, 0x2E58, 0x2E5A, 0x2E5C, 0x3009, 0x300B, 0x300D, 0x300F, 0x3011, 0x3015, 0x3017, 0x3019, 0x301B, 0xFD3E, 0xFE18, 0xFE36, 0xFE38, 0xFE3A, 0xFE3C, 0xFE3E, 0xFE40, 0xFE42, 0xFE44, 0xFE48, 0xFE5A, 0xFE5C, 0xFE5E, 0xFF09, 0xFF3D, 0xFF5D, 0xFF60, 0xFF63); +set.addRange(0x301E, 0x301F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Connector_Punctuation.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Connector_Punctuation.js new file mode 100644 index 0000000000000000000000000000000000000000..e6ea6bb57e05f0e5a0fffdb789fd5a752b4d00da --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Connector_Punctuation.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x5F, 0x2054, 0xFF3F); +set.addRange(0x203F, 0x2040).addRange(0xFE33, 0xFE34).addRange(0xFE4D, 0xFE4F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Control.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Control.js new file mode 100644 index 0000000000000000000000000000000000000000..bcc304ddbe34799e535565d61d7668151d3e17bf --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Control.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x0, 0x1F).addRange(0x7F, 0x9F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Currency_Symbol.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Currency_Symbol.js new file mode 100644 index 0000000000000000000000000000000000000000..f6a40630b664defa4b0aa40140a650c9581cff0b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Currency_Symbol.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x24, 0x58F, 0x60B, 0x9FB, 0xAF1, 0xBF9, 0xE3F, 0x17DB, 0xA838, 0xFDFC, 0xFE69, 0xFF04, 0x1E2FF, 0x1ECB0); +set.addRange(0xA2, 0xA5).addRange(0x7FE, 0x7FF).addRange(0x9F2, 0x9F3).addRange(0x20A0, 0x20C1).addRange(0xFFE0, 0xFFE1).addRange(0xFFE5, 0xFFE6).addRange(0x11FDD, 0x11FE0); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Dash_Punctuation.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Dash_Punctuation.js new file mode 100644 index 0000000000000000000000000000000000000000..d19191c3eecc83e62b8206dbfd62058dbf9c951e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Dash_Punctuation.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2D, 0x58A, 0x5BE, 0x1400, 0x1806, 0x2E17, 0x2E1A, 0x2E40, 0x2E5D, 0x301C, 0x3030, 0x30A0, 0xFE58, 0xFE63, 0xFF0D, 0x10D6E, 0x10EAD); +set.addRange(0x2010, 0x2015).addRange(0x2E3A, 0x2E3B).addRange(0xFE31, 0xFE32); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Decimal_Number.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Decimal_Number.js new file mode 100644 index 0000000000000000000000000000000000000000..8af1990373c8df7f0d14ec191441d797ecfc176d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Decimal_Number.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(); +set.addRange(0x30, 0x39).addRange(0x660, 0x669).addRange(0x6F0, 0x6F9).addRange(0x7C0, 0x7C9).addRange(0x966, 0x96F).addRange(0x9E6, 0x9EF).addRange(0xA66, 0xA6F).addRange(0xAE6, 0xAEF).addRange(0xB66, 0xB6F).addRange(0xBE6, 0xBEF).addRange(0xC66, 0xC6F).addRange(0xCE6, 0xCEF).addRange(0xD66, 0xD6F).addRange(0xDE6, 0xDEF).addRange(0xE50, 0xE59).addRange(0xED0, 0xED9).addRange(0xF20, 0xF29).addRange(0x1040, 0x1049).addRange(0x1090, 0x1099).addRange(0x17E0, 0x17E9).addRange(0x1810, 0x1819).addRange(0x1946, 0x194F).addRange(0x19D0, 0x19D9).addRange(0x1A80, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1B50, 0x1B59).addRange(0x1BB0, 0x1BB9).addRange(0x1C40, 0x1C49).addRange(0x1C50, 0x1C59).addRange(0xA620, 0xA629).addRange(0xA8D0, 0xA8D9).addRange(0xA900, 0xA909).addRange(0xA9D0, 0xA9D9).addRange(0xA9F0, 0xA9F9).addRange(0xAA50, 0xAA59).addRange(0xABF0, 0xABF9).addRange(0xFF10, 0xFF19).addRange(0x104A0, 0x104A9).addRange(0x10D30, 0x10D39).addRange(0x10D40, 0x10D49).addRange(0x11066, 0x1106F).addRange(0x110F0, 0x110F9).addRange(0x11136, 0x1113F).addRange(0x111D0, 0x111D9).addRange(0x112F0, 0x112F9).addRange(0x11450, 0x11459).addRange(0x114D0, 0x114D9).addRange(0x11650, 0x11659).addRange(0x116C0, 0x116C9).addRange(0x116D0, 0x116E3).addRange(0x11730, 0x11739); +set.addRange(0x118E0, 0x118E9).addRange(0x11950, 0x11959).addRange(0x11BF0, 0x11BF9).addRange(0x11C50, 0x11C59).addRange(0x11D50, 0x11D59).addRange(0x11DA0, 0x11DA9).addRange(0x11DE0, 0x11DE9).addRange(0x11F50, 0x11F59).addRange(0x16130, 0x16139).addRange(0x16A60, 0x16A69).addRange(0x16AC0, 0x16AC9).addRange(0x16B50, 0x16B59).addRange(0x16D70, 0x16D79).addRange(0x1CCF0, 0x1CCF9).addRange(0x1D7CE, 0x1D7FF).addRange(0x1E140, 0x1E149).addRange(0x1E2F0, 0x1E2F9).addRange(0x1E4F0, 0x1E4F9).addRange(0x1E5F1, 0x1E5FA).addRange(0x1E950, 0x1E959).addRange(0x1FBF0, 0x1FBF9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Enclosing_Mark.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Enclosing_Mark.js new file mode 100644 index 0000000000000000000000000000000000000000..a99fefafeedb000663516b9d5f5b85218de21c9b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Enclosing_Mark.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1ABE); +set.addRange(0x488, 0x489).addRange(0x20DD, 0x20E0).addRange(0x20E2, 0x20E4).addRange(0xA670, 0xA672); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Final_Punctuation.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Final_Punctuation.js new file mode 100644 index 0000000000000000000000000000000000000000..33035e10f5e498bbeedfb4d3eb25a5cde00e023a --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Final_Punctuation.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xBB, 0x2019, 0x201D, 0x203A, 0x2E03, 0x2E05, 0x2E0A, 0x2E0D, 0x2E1D, 0x2E21); + +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Format.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Format.js new file mode 100644 index 0000000000000000000000000000000000000000..9616c81a08404a591d2183e59a946cd2a746e975 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Format.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xAD, 0x61C, 0x6DD, 0x70F, 0x8E2, 0x180E, 0xFEFF, 0x110BD, 0x110CD, 0xE0001); +set.addRange(0x600, 0x605).addRange(0x890, 0x891).addRange(0x200B, 0x200F).addRange(0x202A, 0x202E).addRange(0x2060, 0x2064).addRange(0x2066, 0x206F).addRange(0xFFF9, 0xFFFB).addRange(0x13430, 0x1343F).addRange(0x1BCA0, 0x1BCA3).addRange(0x1D173, 0x1D17A).addRange(0xE0020, 0xE007F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Initial_Punctuation.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Initial_Punctuation.js new file mode 100644 index 0000000000000000000000000000000000000000..3c1e776f2a35e54874a63b5989b7589fc7eac1e9 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Initial_Punctuation.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xAB, 0x2018, 0x201F, 0x2039, 0x2E02, 0x2E04, 0x2E09, 0x2E0C, 0x2E1C, 0x2E20); +set.addRange(0x201B, 0x201C); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Letter.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Letter.js new file mode 100644 index 0000000000000000000000000000000000000000..f02ec32df0d766c989012bc3c9328dee5d7f7024 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Letter.js @@ -0,0 +1,13 @@ +const set = require('regenerate')(0xAA, 0xB5, 0xBA, 0x2EC, 0x2EE, 0x37F, 0x386, 0x38C, 0x559, 0x6D5, 0x6FF, 0x710, 0x7B1, 0x7FA, 0x81A, 0x824, 0x828, 0x93D, 0x950, 0x9B2, 0x9BD, 0x9CE, 0x9FC, 0xA5E, 0xABD, 0xAD0, 0xAF9, 0xB3D, 0xB71, 0xB83, 0xB9C, 0xBD0, 0xC3D, 0xC80, 0xCBD, 0xD3D, 0xD4E, 0xDBD, 0xE84, 0xEA5, 0xEBD, 0xEC6, 0xF00, 0x103F, 0x1061, 0x108E, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x17DC, 0x18AA, 0x1AA7, 0x1CFA, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2071, 0x207F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214E, 0x2D27, 0x2D2D, 0x2D6F, 0x2E2F, 0xA8FB, 0xA9CF, 0xAA7A, 0xAAB1, 0xAAC0, 0xAAC2, 0xFB1D, 0xFB3E, 0x10808, 0x1083C, 0x10A00, 0x10F27, 0x11075, 0x11144, 0x11147, 0x11176, 0x111DA, 0x111DC, 0x11288, 0x1133D, 0x11350, 0x1138B, 0x1138E, 0x113B7, 0x113D1, 0x113D3, 0x114C7, 0x11644, 0x116B8, 0x11909, 0x1193F, 0x11941, 0x119E1, 0x119E3, 0x11A00, 0x11A3A, 0x11A50, 0x11A9D, 0x11C40, 0x11D46, 0x11D98, 0x11F02, 0x11FB0, 0x16F50, 0x16FE3, 0x1B132, 0x1B155, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1E14E, 0x1E5F0, 0x1E94B, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E); +set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x370, 0x374).addRange(0x376, 0x377).addRange(0x37A, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x620, 0x64A).addRange(0x66E, 0x66F).addRange(0x671, 0x6D3).addRange(0x6E5, 0x6E6).addRange(0x6EE, 0x6EF).addRange(0x6FA, 0x6FC).addRange(0x712, 0x72F).addRange(0x74D, 0x7A5).addRange(0x7CA, 0x7EA).addRange(0x7F4, 0x7F5).addRange(0x800, 0x815).addRange(0x840, 0x858).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88F).addRange(0x8A0, 0x8C9).addRange(0x904, 0x939).addRange(0x958, 0x961).addRange(0x971, 0x980).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E1).addRange(0x9F0, 0x9F1).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33); +set.addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA59, 0xA5C).addRange(0xA72, 0xA74).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xAE0, 0xAE1).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB61).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xC05, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC58, 0xC5A).addRange(0xC5C, 0xC5D).addRange(0xC60, 0xC61).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCDC, 0xCDE).addRange(0xCE0, 0xCE1).addRange(0xCF1, 0xCF2).addRange(0xD04, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD3A).addRange(0xD54, 0xD56).addRange(0xD5F, 0xD61).addRange(0xD7A, 0xD7F).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB); +set.addRange(0xDC0, 0xDC6).addRange(0xE01, 0xE30).addRange(0xE32, 0xE33).addRange(0xE40, 0xE46).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEB0).addRange(0xEB2, 0xEB3).addRange(0xEC0, 0xEC4).addRange(0xEDC, 0xEDF).addRange(0xF40, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF88, 0xF8C).addRange(0x1000, 0x102A).addRange(0x1050, 0x1055).addRange(0x105A, 0x105D).addRange(0x1065, 0x1066).addRange(0x106E, 0x1070).addRange(0x1075, 0x1081).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x1380, 0x138F).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16F1, 0x16F8).addRange(0x1700, 0x1711).addRange(0x171F, 0x1731).addRange(0x1740, 0x1751).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1780, 0x17B3).addRange(0x1820, 0x1878); +set.addRange(0x1880, 0x1884).addRange(0x1887, 0x18A8).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1950, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x1A00, 0x1A16).addRange(0x1A20, 0x1A54).addRange(0x1B05, 0x1B33).addRange(0x1B45, 0x1B4C).addRange(0x1B83, 0x1BA0).addRange(0x1BAE, 0x1BAF).addRange(0x1BBA, 0x1BE5).addRange(0x1C00, 0x1C23).addRange(0x1C4D, 0x1C4F).addRange(0x1C5A, 0x1C7D).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF6).addRange(0x1D00, 0x1DBF).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x2090, 0x209C).addRange(0x210A, 0x2113).addRange(0x2119, 0x211D).addRange(0x212A, 0x212D).addRange(0x212F, 0x2139).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2183, 0x2184).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3); +set.addRange(0x2D00, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x3005, 0x3006).addRange(0x3031, 0x3035).addRange(0x303B, 0x303C).addRange(0x3041, 0x3096).addRange(0x309D, 0x309F).addRange(0x30A1, 0x30FA).addRange(0x30FC, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA48C).addRange(0xA4D0, 0xA4FD).addRange(0xA500, 0xA60C).addRange(0xA610, 0xA61F).addRange(0xA62A, 0xA62B).addRange(0xA640, 0xA66E).addRange(0xA67F, 0xA69D).addRange(0xA6A0, 0xA6E5).addRange(0xA717, 0xA71F).addRange(0xA722, 0xA788).addRange(0xA78B, 0xA7DC).addRange(0xA7F1, 0xA801).addRange(0xA803, 0xA805).addRange(0xA807, 0xA80A).addRange(0xA80C, 0xA822).addRange(0xA840, 0xA873).addRange(0xA882, 0xA8B3).addRange(0xA8F2, 0xA8F7).addRange(0xA8FD, 0xA8FE).addRange(0xA90A, 0xA925).addRange(0xA930, 0xA946).addRange(0xA960, 0xA97C).addRange(0xA984, 0xA9B2).addRange(0xA9E0, 0xA9E4).addRange(0xA9E6, 0xA9EF).addRange(0xA9FA, 0xA9FE).addRange(0xAA00, 0xAA28).addRange(0xAA40, 0xAA42); +set.addRange(0xAA44, 0xAA4B).addRange(0xAA60, 0xAA76).addRange(0xAA7E, 0xAAAF).addRange(0xAAB5, 0xAAB6).addRange(0xAAB9, 0xAABD).addRange(0xAADB, 0xAADD).addRange(0xAAE0, 0xAAEA).addRange(0xAAF2, 0xAAF4).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABE2).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1F, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFB).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0xFF66, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0); +set.addRange(0x10300, 0x1031F).addRange(0x1032D, 0x10340).addRange(0x10342, 0x10349).addRange(0x10350, 0x10375).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x10400, 0x1049D).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915).addRange(0x10920, 0x10939).addRange(0x10940, 0x10959).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A10, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7).addRange(0x10AC9, 0x10AE4).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91); +set.addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D00, 0x10D23).addRange(0x10D4A, 0x10D65).addRange(0x10D6F, 0x10D85).addRange(0x10E80, 0x10EA9).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC7).addRange(0x10F00, 0x10F1C).addRange(0x10F30, 0x10F45).addRange(0x10F70, 0x10F81).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11003, 0x11037).addRange(0x11071, 0x11072).addRange(0x11083, 0x110AF).addRange(0x110D0, 0x110E8).addRange(0x11103, 0x11126).addRange(0x11150, 0x11172).addRange(0x11183, 0x111B2).addRange(0x111C1, 0x111C4).addRange(0x11200, 0x11211).addRange(0x11213, 0x1122B).addRange(0x1123F, 0x11240).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112DE).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1135D, 0x11361).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x11400, 0x11434).addRange(0x11447, 0x1144A).addRange(0x1145F, 0x11461).addRange(0x11480, 0x114AF).addRange(0x114C4, 0x114C5).addRange(0x11580, 0x115AE).addRange(0x115D8, 0x115DB).addRange(0x11600, 0x1162F).addRange(0x11680, 0x116AA).addRange(0x11700, 0x1171A).addRange(0x11740, 0x11746).addRange(0x11800, 0x1182B); +set.addRange(0x118A0, 0x118DF).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x1192F).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D0).addRange(0x11A0B, 0x11A32).addRange(0x11A5C, 0x11A89).addRange(0x11AB0, 0x11AF8).addRange(0x11BC0, 0x11BE0).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C2E).addRange(0x11C72, 0x11C8F).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D30).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D89).addRange(0x11DB0, 0x11DDB).addRange(0x11EE0, 0x11EF2).addRange(0x11F04, 0x11F10).addRange(0x11F12, 0x11F33).addRange(0x12000, 0x12399).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13441, 0x13446).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x1611D).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A70, 0x16ABE).addRange(0x16AD0, 0x16AED).addRange(0x16B00, 0x16B2F).addRange(0x16B40, 0x16B43).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D6C).addRange(0x16E40, 0x16E7F).addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3).addRange(0x16F00, 0x16F4A).addRange(0x16F93, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x16FF2, 0x16FF3).addRange(0x17000, 0x18CD5).addRange(0x18CFF, 0x18D1E).addRange(0x18D80, 0x18DF2); +set.addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E137, 0x1E13D).addRange(0x1E290, 0x1E2AD).addRange(0x1E2C0, 0x1E2EB).addRange(0x1E4D0, 0x1E4EB).addRange(0x1E5D0, 0x1E5ED).addRange(0x1E6C0, 0x1E6DE).addRange(0x1E6E0, 0x1E6E2).addRange(0x1E6E4, 0x1E6E5).addRange(0x1E6E7, 0x1E6ED); +set.addRange(0x1E6F0, 0x1E6F4).addRange(0x1E6FE, 0x1E6FF).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E900, 0x1E943).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Letter_Number.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Letter_Number.js new file mode 100644 index 0000000000000000000000000000000000000000..979b4ce77f7a40ba0970bad35388fe8731f2d5e8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Letter_Number.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x3007, 0x10341, 0x1034A); +set.addRange(0x16EE, 0x16F0).addRange(0x2160, 0x2182).addRange(0x2185, 0x2188).addRange(0x3021, 0x3029).addRange(0x3038, 0x303A).addRange(0xA6E6, 0xA6EF).addRange(0x10140, 0x10174).addRange(0x103D1, 0x103D5).addRange(0x12400, 0x1246E).addRange(0x16FF4, 0x16FF6); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Line_Separator.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Line_Separator.js new file mode 100644 index 0000000000000000000000000000000000000000..b08cf2763c922d2a4cd5882411d3af4175f52962 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Line_Separator.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2028); + +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Lowercase_Letter.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Lowercase_Letter.js new file mode 100644 index 0000000000000000000000000000000000000000..5867e93cabc9e451ab7d5ce5e071d7e26bc0b979 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Lowercase_Letter.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0xB5, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x12F, 0x131, 0x133, 0x135, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x183, 0x185, 0x188, 0x192, 0x195, 0x19E, 0x1A1, 0x1A3, 0x1A5, 0x1A8, 0x1AD, 0x1B0, 0x1B4, 0x1B6, 0x1C6, 0x1C9, 0x1CC, 0x1CE, 0x1D0, 0x1D2, 0x1D4, 0x1D6, 0x1D8, 0x1DA, 0x1DF, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x1E9, 0x1EB, 0x1ED, 0x1F3, 0x1F5, 0x1F9, 0x1FB, 0x1FD, 0x1FF, 0x201, 0x203, 0x205, 0x207, 0x209, 0x20B, 0x20D, 0x20F, 0x211, 0x213, 0x215, 0x217, 0x219, 0x21B, 0x21D, 0x21F, 0x221, 0x223, 0x225, 0x227, 0x229, 0x22B, 0x22D, 0x22F, 0x231, 0x23C, 0x242, 0x247, 0x249, 0x24B, 0x24D, 0x371, 0x373, 0x377, 0x390, 0x3D9, 0x3DB, 0x3DD, 0x3DF, 0x3E1, 0x3E3, 0x3E5, 0x3E7, 0x3E9, 0x3EB, 0x3ED, 0x3F5, 0x3F8, 0x461, 0x463, 0x465, 0x467, 0x469, 0x46B, 0x46D, 0x46F, 0x471, 0x473, 0x475, 0x477, 0x479, 0x47B, 0x47D, 0x47F, 0x481, 0x48B, 0x48D, 0x48F, 0x491, 0x493, 0x495, 0x497, 0x499, 0x49B, 0x49D, 0x49F, 0x4A1, 0x4A3, 0x4A5, 0x4A7, 0x4A9, 0x4AB, 0x4AD, 0x4AF, 0x4B1, 0x4B3, 0x4B5, 0x4B7, 0x4B9, 0x4BB, 0x4BD, 0x4BF, 0x4C2, 0x4C4, 0x4C6, 0x4C8, 0x4CA, 0x4CC, 0x4D1, 0x4D3, 0x4D5, 0x4D7, 0x4D9, 0x4DB, 0x4DD, 0x4DF, 0x4E1, 0x4E3, 0x4E5, 0x4E7, 0x4E9, 0x4EB, 0x4ED, 0x4EF, 0x4F1, 0x4F3, 0x4F5, 0x4F7, 0x4F9, 0x4FB, 0x4FD, 0x4FF, 0x501, 0x503, 0x505, 0x507, 0x509, 0x50B, 0x50D, 0x50F, 0x511, 0x513, 0x515, 0x517, 0x519, 0x51B, 0x51D, 0x51F, 0x521, 0x523, 0x525, 0x527, 0x529, 0x52B, 0x52D, 0x52F, 0x1C8A, 0x1E01, 0x1E03, 0x1E05, 0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13, 0x1E15, 0x1E17, 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27, 0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39, 0x1E3B, 0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F, 0x1E51, 0x1E53, 0x1E55, 0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63, 0x1E65, 0x1E67, 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77, 0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89, 0x1E8B, 0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1E9F, 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9, 0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, 0x1ED1, 0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EE3, 0x1EE5, 0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9, 0x1EFB, 0x1EFD, 0x1FBE, 0x210A, 0x2113, 0x212F, 0x2134, 0x2139, 0x214E, 0x2184, 0x2C61, 0x2C68, 0x2C6A, 0x2C6C, 0x2C71, 0x2C81, 0x2C83, 0x2C85, 0x2C87, 0x2C89, 0x2C8B, 0x2C8D, 0x2C8F, 0x2C91, 0x2C93, 0x2C95, 0x2C97, 0x2C99, 0x2C9B, 0x2C9D, 0x2C9F, 0x2CA1, 0x2CA3, 0x2CA5, 0x2CA7, 0x2CA9, 0x2CAB, 0x2CAD, 0x2CAF, 0x2CB1, 0x2CB3, 0x2CB5, 0x2CB7, 0x2CB9, 0x2CBB, 0x2CBD, 0x2CBF, 0x2CC1, 0x2CC3, 0x2CC5, 0x2CC7, 0x2CC9, 0x2CCB, 0x2CCD, 0x2CCF, 0x2CD1, 0x2CD3, 0x2CD5, 0x2CD7, 0x2CD9, 0x2CDB, 0x2CDD, 0x2CDF, 0x2CE1, 0x2CEC, 0x2CEE, 0x2CF3, 0x2D27, 0x2D2D, 0xA641, 0xA643, 0xA645, 0xA647, 0xA649, 0xA64B, 0xA64D, 0xA64F, 0xA651, 0xA653, 0xA655, 0xA657, 0xA659, 0xA65B, 0xA65D, 0xA65F, 0xA661, 0xA663, 0xA665, 0xA667, 0xA669, 0xA66B, 0xA66D, 0xA681, 0xA683, 0xA685, 0xA687, 0xA689, 0xA68B, 0xA68D, 0xA68F, 0xA691, 0xA693, 0xA695, 0xA697, 0xA699, 0xA69B, 0xA723, 0xA725, 0xA727, 0xA729, 0xA72B, 0xA72D, 0xA733, 0xA735, 0xA737, 0xA739, 0xA73B, 0xA73D, 0xA73F, 0xA741, 0xA743, 0xA745, 0xA747, 0xA749, 0xA74B, 0xA74D, 0xA74F, 0xA751, 0xA753, 0xA755, 0xA757, 0xA759, 0xA75B, 0xA75D, 0xA75F, 0xA761, 0xA763, 0xA765, 0xA767, 0xA769, 0xA76B, 0xA76D, 0xA76F, 0xA77A, 0xA77C, 0xA77F, 0xA781, 0xA783, 0xA785, 0xA787, 0xA78C, 0xA78E, 0xA791, 0xA797, 0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3, 0xA7A5, 0xA7A7, 0xA7A9, 0xA7AF, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C1, 0xA7C3, 0xA7C8, 0xA7CA, 0xA7CD, 0xA7CF, 0xA7D1, 0xA7D3, 0xA7D5, 0xA7D7, 0xA7D9, 0xA7DB, 0xA7F6, 0xA7FA, 0x1D4BB, 0x1D7CB); +set.addRange(0x61, 0x7A).addRange(0xDF, 0xF6).addRange(0xF8, 0xFF).addRange(0x137, 0x138).addRange(0x148, 0x149).addRange(0x17E, 0x180).addRange(0x18C, 0x18D).addRange(0x199, 0x19B).addRange(0x1AA, 0x1AB).addRange(0x1B9, 0x1BA).addRange(0x1BD, 0x1BF).addRange(0x1DC, 0x1DD).addRange(0x1EF, 0x1F0).addRange(0x233, 0x239).addRange(0x23F, 0x240).addRange(0x24F, 0x293).addRange(0x296, 0x2AF).addRange(0x37B, 0x37D).addRange(0x3AC, 0x3CE).addRange(0x3D0, 0x3D1).addRange(0x3D5, 0x3D7).addRange(0x3EF, 0x3F3).addRange(0x3FB, 0x3FC).addRange(0x430, 0x45F).addRange(0x4CE, 0x4CF).addRange(0x560, 0x588).addRange(0x10D0, 0x10FA).addRange(0x10FD, 0x10FF).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C88).addRange(0x1D00, 0x1D2B).addRange(0x1D6B, 0x1D77).addRange(0x1D79, 0x1D9A).addRange(0x1E95, 0x1E9D).addRange(0x1EFF, 0x1F07).addRange(0x1F10, 0x1F15).addRange(0x1F20, 0x1F27).addRange(0x1F30, 0x1F37).addRange(0x1F40, 0x1F45).addRange(0x1F50, 0x1F57).addRange(0x1F60, 0x1F67).addRange(0x1F70, 0x1F7D).addRange(0x1F80, 0x1F87).addRange(0x1F90, 0x1F97).addRange(0x1FA0, 0x1FA7).addRange(0x1FB0, 0x1FB4).addRange(0x1FB6, 0x1FB7).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FC7).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FD7); +set.addRange(0x1FE0, 0x1FE7).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FF7).addRange(0x210E, 0x210F).addRange(0x213C, 0x213D).addRange(0x2146, 0x2149).addRange(0x2C30, 0x2C5F).addRange(0x2C65, 0x2C66).addRange(0x2C73, 0x2C74).addRange(0x2C76, 0x2C7B).addRange(0x2CE3, 0x2CE4).addRange(0x2D00, 0x2D25).addRange(0xA72F, 0xA731).addRange(0xA771, 0xA778).addRange(0xA793, 0xA795).addRange(0xAB30, 0xAB5A).addRange(0xAB60, 0xAB68).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF41, 0xFF5A).addRange(0x10428, 0x1044F).addRange(0x104D8, 0x104FB).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10CC0, 0x10CF2).addRange(0x10D70, 0x10D85).addRange(0x118C0, 0x118DF).addRange(0x16E60, 0x16E7F).addRange(0x16EBB, 0x16ED3).addRange(0x1D41A, 0x1D433).addRange(0x1D44E, 0x1D454).addRange(0x1D456, 0x1D467).addRange(0x1D482, 0x1D49B).addRange(0x1D4B6, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D4CF).addRange(0x1D4EA, 0x1D503).addRange(0x1D51E, 0x1D537).addRange(0x1D552, 0x1D56B).addRange(0x1D586, 0x1D59F).addRange(0x1D5BA, 0x1D5D3).addRange(0x1D5EE, 0x1D607).addRange(0x1D622, 0x1D63B).addRange(0x1D656, 0x1D66F).addRange(0x1D68A, 0x1D6A5).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6E1).addRange(0x1D6FC, 0x1D714); +set.addRange(0x1D716, 0x1D71B).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D755).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D78F).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7C9).addRange(0x1DF00, 0x1DF09).addRange(0x1DF0B, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E922, 0x1E943); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Mark.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Mark.js new file mode 100644 index 0000000000000000000000000000000000000000..6254aa5bdae4e191ffcaf3208fa589da51c5538d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Mark.js @@ -0,0 +1,7 @@ +const set = require('regenerate')(0x5BF, 0x5C7, 0x670, 0x711, 0x7FD, 0x9BC, 0x9D7, 0x9FE, 0xA3C, 0xA51, 0xA75, 0xABC, 0xB3C, 0xB82, 0xBD7, 0xC3C, 0xCBC, 0xCF3, 0xD57, 0xDCA, 0xDD6, 0xE31, 0xEB1, 0xF35, 0xF37, 0xF39, 0xFC6, 0x108F, 0x17DD, 0x180F, 0x18A9, 0x1A7F, 0x1CED, 0x1CF4, 0x2D7F, 0xA802, 0xA806, 0xA80B, 0xA82C, 0xA8FF, 0xA9E5, 0xAA43, 0xAAB0, 0xAAC1, 0xFB1E, 0x101FD, 0x102E0, 0x10A3F, 0x11070, 0x110C2, 0x11173, 0x1123E, 0x11241, 0x11357, 0x113C2, 0x113C5, 0x113D2, 0x1145E, 0x11940, 0x119E4, 0x11A47, 0x11D3A, 0x11D47, 0x11F03, 0x11F5A, 0x13440, 0x16F4F, 0x16FE4, 0x1DA75, 0x1DA84, 0x1E08F, 0x1E2AE, 0x1E6E3, 0x1E6E6, 0x1E6F5); +set.addRange(0x300, 0x36F).addRange(0x483, 0x489).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x610, 0x61A).addRange(0x64B, 0x65F).addRange(0x6D6, 0x6DC).addRange(0x6DF, 0x6E4).addRange(0x6E7, 0x6E8).addRange(0x6EA, 0x6ED).addRange(0x730, 0x74A).addRange(0x7A6, 0x7B0).addRange(0x7EB, 0x7F3).addRange(0x816, 0x819).addRange(0x81B, 0x823).addRange(0x825, 0x827).addRange(0x829, 0x82D).addRange(0x859, 0x85B).addRange(0x897, 0x89F).addRange(0x8CA, 0x8E1).addRange(0x8E3, 0x903).addRange(0x93A, 0x93C).addRange(0x93E, 0x94F).addRange(0x951, 0x957).addRange(0x962, 0x963).addRange(0x981, 0x983).addRange(0x9BE, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CD).addRange(0x9E2, 0x9E3).addRange(0xA01, 0xA03).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA70, 0xA71).addRange(0xA81, 0xA83).addRange(0xABE, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACD).addRange(0xAE2, 0xAE3).addRange(0xAFA, 0xAFF).addRange(0xB01, 0xB03).addRange(0xB3E, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4D).addRange(0xB55, 0xB57).addRange(0xB62, 0xB63).addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCD); +set.addRange(0xC00, 0xC04).addRange(0xC3E, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC62, 0xC63).addRange(0xC81, 0xC83).addRange(0xCBE, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCE2, 0xCE3).addRange(0xD00, 0xD03).addRange(0xD3B, 0xD3C).addRange(0xD3E, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4D).addRange(0xD62, 0xD63).addRange(0xD81, 0xD83).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDF2, 0xDF3).addRange(0xE34, 0xE3A).addRange(0xE47, 0xE4E).addRange(0xEB4, 0xEBC).addRange(0xEC8, 0xECE).addRange(0xF18, 0xF19).addRange(0xF3E, 0xF3F).addRange(0xF71, 0xF84).addRange(0xF86, 0xF87).addRange(0xF8D, 0xF97).addRange(0xF99, 0xFBC).addRange(0x102B, 0x103E).addRange(0x1056, 0x1059).addRange(0x105E, 0x1060).addRange(0x1062, 0x1064).addRange(0x1067, 0x106D).addRange(0x1071, 0x1074).addRange(0x1082, 0x108D).addRange(0x109A, 0x109D).addRange(0x135D, 0x135F).addRange(0x1712, 0x1715).addRange(0x1732, 0x1734).addRange(0x1752, 0x1753).addRange(0x1772, 0x1773).addRange(0x17B4, 0x17D3).addRange(0x180B, 0x180D).addRange(0x1885, 0x1886).addRange(0x1920, 0x192B).addRange(0x1930, 0x193B).addRange(0x1A17, 0x1A1B); +set.addRange(0x1A55, 0x1A5E).addRange(0x1A60, 0x1A7C).addRange(0x1AB0, 0x1ADD).addRange(0x1AE0, 0x1AEB).addRange(0x1B00, 0x1B04).addRange(0x1B34, 0x1B44).addRange(0x1B6B, 0x1B73).addRange(0x1B80, 0x1B82).addRange(0x1BA1, 0x1BAD).addRange(0x1BE6, 0x1BF3).addRange(0x1C24, 0x1C37).addRange(0x1CD0, 0x1CD2).addRange(0x1CD4, 0x1CE8).addRange(0x1CF7, 0x1CF9).addRange(0x1DC0, 0x1DFF).addRange(0x20D0, 0x20F0).addRange(0x2CEF, 0x2CF1).addRange(0x2DE0, 0x2DFF).addRange(0x302A, 0x302F).addRange(0x3099, 0x309A).addRange(0xA66F, 0xA672).addRange(0xA674, 0xA67D).addRange(0xA69E, 0xA69F).addRange(0xA6F0, 0xA6F1).addRange(0xA823, 0xA827).addRange(0xA880, 0xA881).addRange(0xA8B4, 0xA8C5).addRange(0xA8E0, 0xA8F1).addRange(0xA926, 0xA92D).addRange(0xA947, 0xA953).addRange(0xA980, 0xA983).addRange(0xA9B3, 0xA9C0).addRange(0xAA29, 0xAA36).addRange(0xAA4C, 0xAA4D).addRange(0xAA7B, 0xAA7D).addRange(0xAAB2, 0xAAB4).addRange(0xAAB7, 0xAAB8).addRange(0xAABE, 0xAABF).addRange(0xAAEB, 0xAAEF).addRange(0xAAF5, 0xAAF6).addRange(0xABE3, 0xABEA).addRange(0xABEC, 0xABED).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2F).addRange(0x10376, 0x1037A).addRange(0x10A01, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A0F).addRange(0x10A38, 0x10A3A).addRange(0x10AE5, 0x10AE6).addRange(0x10D24, 0x10D27); +set.addRange(0x10D69, 0x10D6D).addRange(0x10EAB, 0x10EAC).addRange(0x10EFA, 0x10EFF).addRange(0x10F46, 0x10F50).addRange(0x10F82, 0x10F85).addRange(0x11000, 0x11002).addRange(0x11038, 0x11046).addRange(0x11073, 0x11074).addRange(0x1107F, 0x11082).addRange(0x110B0, 0x110BA).addRange(0x11100, 0x11102).addRange(0x11127, 0x11134).addRange(0x11145, 0x11146).addRange(0x11180, 0x11182).addRange(0x111B3, 0x111C0).addRange(0x111C9, 0x111CC).addRange(0x111CE, 0x111CF).addRange(0x1122C, 0x11237).addRange(0x112DF, 0x112EA).addRange(0x11300, 0x11303).addRange(0x1133B, 0x1133C).addRange(0x1133E, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x11362, 0x11363).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x113B8, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113D0).addRange(0x113E1, 0x113E2).addRange(0x11435, 0x11446).addRange(0x114B0, 0x114C3).addRange(0x115AF, 0x115B5).addRange(0x115B8, 0x115C0).addRange(0x115DC, 0x115DD).addRange(0x11630, 0x11640).addRange(0x116AB, 0x116B7).addRange(0x1171D, 0x1172B).addRange(0x1182C, 0x1183A).addRange(0x11930, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x1193E).addRange(0x11942, 0x11943).addRange(0x119D1, 0x119D7).addRange(0x119DA, 0x119E0).addRange(0x11A01, 0x11A0A).addRange(0x11A33, 0x11A39).addRange(0x11A3B, 0x11A3E).addRange(0x11A51, 0x11A5B).addRange(0x11A8A, 0x11A99); +set.addRange(0x11B60, 0x11B67).addRange(0x11C2F, 0x11C36).addRange(0x11C38, 0x11C3F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6).addRange(0x11D31, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D45).addRange(0x11D8A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D97).addRange(0x11EF3, 0x11EF6).addRange(0x11F00, 0x11F01).addRange(0x11F34, 0x11F3A).addRange(0x11F3E, 0x11F42).addRange(0x13447, 0x13455).addRange(0x1611E, 0x1612F).addRange(0x16AF0, 0x16AF4).addRange(0x16B30, 0x16B36).addRange(0x16F51, 0x16F87).addRange(0x16F8F, 0x16F92).addRange(0x16FF0, 0x16FF1).addRange(0x1BC9D, 0x1BC9E).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D165, 0x1D169).addRange(0x1D16D, 0x1D172).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1D242, 0x1D244).addRange(0x1DA00, 0x1DA36).addRange(0x1DA3B, 0x1DA6C).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E130, 0x1E136).addRange(0x1E2EC, 0x1E2EF).addRange(0x1E4EC, 0x1E4EF).addRange(0x1E5EE, 0x1E5EF).addRange(0x1E6EE, 0x1E6EF).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E944, 0x1E94A).addRange(0xE0100, 0xE01EF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Math_Symbol.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Math_Symbol.js new file mode 100644 index 0000000000000000000000000000000000000000..3e9182e7b33fa072f49ba32344bfe126ee1e8621 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Math_Symbol.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2B, 0x7C, 0x7E, 0xAC, 0xB1, 0xD7, 0xF7, 0x3F6, 0x2044, 0x2052, 0x2118, 0x214B, 0x21A0, 0x21A3, 0x21A6, 0x21AE, 0x21D2, 0x21D4, 0x237C, 0x25B7, 0x25C1, 0x266F, 0xFB29, 0xFE62, 0xFF0B, 0xFF5C, 0xFF5E, 0xFFE2, 0x1CEF0, 0x1D6C1, 0x1D6DB, 0x1D6FB, 0x1D715, 0x1D735, 0x1D74F, 0x1D76F, 0x1D789, 0x1D7A9, 0x1D7C3); +set.addRange(0x3C, 0x3E).addRange(0x606, 0x608).addRange(0x207A, 0x207C).addRange(0x208A, 0x208C).addRange(0x2140, 0x2144).addRange(0x2190, 0x2194).addRange(0x219A, 0x219B).addRange(0x21CE, 0x21CF).addRange(0x21F4, 0x22FF).addRange(0x2320, 0x2321).addRange(0x239B, 0x23B3).addRange(0x23DC, 0x23E1).addRange(0x25F8, 0x25FF).addRange(0x27C0, 0x27C4).addRange(0x27C7, 0x27E5).addRange(0x27F0, 0x27FF).addRange(0x2900, 0x2982).addRange(0x2999, 0x29D7).addRange(0x29DC, 0x29FB).addRange(0x29FE, 0x2AFF).addRange(0x2B30, 0x2B44).addRange(0x2B47, 0x2B4C).addRange(0xFE64, 0xFE66).addRange(0xFF1C, 0xFF1E).addRange(0xFFE9, 0xFFEC).addRange(0x10D8E, 0x10D8F).addRange(0x1EEF0, 0x1EEF1).addRange(0x1F8D0, 0x1F8D8); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Modifier_Letter.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Modifier_Letter.js new file mode 100644 index 0000000000000000000000000000000000000000..9dd0725d0bbd486f8d9e858b6c2bd4ec6915ab9e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Modifier_Letter.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2EC, 0x2EE, 0x374, 0x37A, 0x559, 0x640, 0x7FA, 0x81A, 0x824, 0x828, 0x8C9, 0x971, 0xE46, 0xEC6, 0x10FC, 0x17D7, 0x1843, 0x1AA7, 0x1D78, 0x2071, 0x207F, 0x2D6F, 0x2E2F, 0x3005, 0x303B, 0xA015, 0xA60C, 0xA67F, 0xA770, 0xA788, 0xA9CF, 0xA9E6, 0xAA70, 0xAADD, 0xAB69, 0xFF70, 0x10D4E, 0x10D6F, 0x10EC5, 0x11DD9, 0x16FE3, 0x1E4EB, 0x1E6FF, 0x1E94B); +set.addRange(0x2B0, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x6E5, 0x6E6).addRange(0x7F4, 0x7F5).addRange(0x1C78, 0x1C7D).addRange(0x1D2C, 0x1D6A).addRange(0x1D9B, 0x1DBF).addRange(0x2090, 0x209C).addRange(0x2C7C, 0x2C7D).addRange(0x3031, 0x3035).addRange(0x309D, 0x309E).addRange(0x30FC, 0x30FE).addRange(0xA4F8, 0xA4FD).addRange(0xA69C, 0xA69D).addRange(0xA717, 0xA71F).addRange(0xA7F1, 0xA7F4).addRange(0xA7F8, 0xA7F9).addRange(0xAAF3, 0xAAF4).addRange(0xAB5C, 0xAB5F).addRange(0xFF9E, 0xFF9F).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x16B40, 0x16B43).addRange(0x16D40, 0x16D42).addRange(0x16D6B, 0x16D6C).addRange(0x16F93, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x16FF2, 0x16FF3).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1E030, 0x1E06D).addRange(0x1E137, 0x1E13D); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Modifier_Symbol.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Modifier_Symbol.js new file mode 100644 index 0000000000000000000000000000000000000000..8c1c748974bea347bdcd607202c21f2106db1ce4 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Modifier_Symbol.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x5E, 0x60, 0xA8, 0xAF, 0xB4, 0xB8, 0x2ED, 0x375, 0x888, 0x1FBD, 0xAB5B, 0xFF3E, 0xFF40, 0xFFE3); +set.addRange(0x2C2, 0x2C5).addRange(0x2D2, 0x2DF).addRange(0x2E5, 0x2EB).addRange(0x2EF, 0x2FF).addRange(0x384, 0x385).addRange(0x1FBF, 0x1FC1).addRange(0x1FCD, 0x1FCF).addRange(0x1FDD, 0x1FDF).addRange(0x1FED, 0x1FEF).addRange(0x1FFD, 0x1FFE).addRange(0x309B, 0x309C).addRange(0xA700, 0xA716).addRange(0xA720, 0xA721).addRange(0xA789, 0xA78A).addRange(0xAB6A, 0xAB6B).addRange(0xFBB2, 0xFBC2).addRange(0x1F3FB, 0x1F3FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Nonspacing_Mark.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Nonspacing_Mark.js new file mode 100644 index 0000000000000000000000000000000000000000..121fe66a5c95c5c5e9c0e4dcfe57fe6be4a172e3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Nonspacing_Mark.js @@ -0,0 +1,7 @@ +const set = require('regenerate')(0x5BF, 0x5C7, 0x670, 0x711, 0x7FD, 0x93A, 0x93C, 0x94D, 0x981, 0x9BC, 0x9CD, 0x9FE, 0xA3C, 0xA51, 0xA75, 0xABC, 0xACD, 0xB01, 0xB3C, 0xB3F, 0xB4D, 0xB82, 0xBC0, 0xBCD, 0xC00, 0xC04, 0xC3C, 0xC81, 0xCBC, 0xCBF, 0xCC6, 0xD4D, 0xD81, 0xDCA, 0xDD6, 0xE31, 0xEB1, 0xF35, 0xF37, 0xF39, 0xFC6, 0x1082, 0x108D, 0x109D, 0x17C6, 0x17DD, 0x180F, 0x18A9, 0x1932, 0x1A1B, 0x1A56, 0x1A60, 0x1A62, 0x1A7F, 0x1B34, 0x1B3C, 0x1B42, 0x1BE6, 0x1BED, 0x1CED, 0x1CF4, 0x20E1, 0x2D7F, 0xA66F, 0xA802, 0xA806, 0xA80B, 0xA82C, 0xA8FF, 0xA9B3, 0xA9E5, 0xAA43, 0xAA4C, 0xAA7C, 0xAAB0, 0xAAC1, 0xAAF6, 0xABE5, 0xABE8, 0xABED, 0xFB1E, 0x101FD, 0x102E0, 0x10A3F, 0x11001, 0x11070, 0x110C2, 0x11173, 0x111CF, 0x11234, 0x1123E, 0x11241, 0x112DF, 0x11340, 0x113CE, 0x113D0, 0x113D2, 0x11446, 0x1145E, 0x114BA, 0x1163D, 0x116AB, 0x116AD, 0x116B7, 0x1171D, 0x1171F, 0x1193E, 0x11943, 0x119E0, 0x11A47, 0x11B60, 0x11B66, 0x11C3F, 0x11D3A, 0x11D47, 0x11D95, 0x11D97, 0x11F40, 0x11F42, 0x11F5A, 0x13440, 0x16F4F, 0x16FE4, 0x1DA75, 0x1DA84, 0x1E08F, 0x1E2AE, 0x1E6E3, 0x1E6E6, 0x1E6F5); +set.addRange(0x300, 0x36F).addRange(0x483, 0x487).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x610, 0x61A).addRange(0x64B, 0x65F).addRange(0x6D6, 0x6DC).addRange(0x6DF, 0x6E4).addRange(0x6E7, 0x6E8).addRange(0x6EA, 0x6ED).addRange(0x730, 0x74A).addRange(0x7A6, 0x7B0).addRange(0x7EB, 0x7F3).addRange(0x816, 0x819).addRange(0x81B, 0x823).addRange(0x825, 0x827).addRange(0x829, 0x82D).addRange(0x859, 0x85B).addRange(0x897, 0x89F).addRange(0x8CA, 0x8E1).addRange(0x8E3, 0x902).addRange(0x941, 0x948).addRange(0x951, 0x957).addRange(0x962, 0x963).addRange(0x9C1, 0x9C4).addRange(0x9E2, 0x9E3).addRange(0xA01, 0xA02).addRange(0xA41, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA70, 0xA71).addRange(0xA81, 0xA82).addRange(0xAC1, 0xAC5).addRange(0xAC7, 0xAC8).addRange(0xAE2, 0xAE3).addRange(0xAFA, 0xAFF).addRange(0xB41, 0xB44).addRange(0xB55, 0xB56).addRange(0xB62, 0xB63).addRange(0xC3E, 0xC40).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC62, 0xC63).addRange(0xCCC, 0xCCD).addRange(0xCE2, 0xCE3).addRange(0xD00, 0xD01).addRange(0xD3B, 0xD3C).addRange(0xD41, 0xD44).addRange(0xD62, 0xD63); +set.addRange(0xDD2, 0xDD4).addRange(0xE34, 0xE3A).addRange(0xE47, 0xE4E).addRange(0xEB4, 0xEBC).addRange(0xEC8, 0xECE).addRange(0xF18, 0xF19).addRange(0xF71, 0xF7E).addRange(0xF80, 0xF84).addRange(0xF86, 0xF87).addRange(0xF8D, 0xF97).addRange(0xF99, 0xFBC).addRange(0x102D, 0x1030).addRange(0x1032, 0x1037).addRange(0x1039, 0x103A).addRange(0x103D, 0x103E).addRange(0x1058, 0x1059).addRange(0x105E, 0x1060).addRange(0x1071, 0x1074).addRange(0x1085, 0x1086).addRange(0x135D, 0x135F).addRange(0x1712, 0x1714).addRange(0x1732, 0x1733).addRange(0x1752, 0x1753).addRange(0x1772, 0x1773).addRange(0x17B4, 0x17B5).addRange(0x17B7, 0x17BD).addRange(0x17C9, 0x17D3).addRange(0x180B, 0x180D).addRange(0x1885, 0x1886).addRange(0x1920, 0x1922).addRange(0x1927, 0x1928).addRange(0x1939, 0x193B).addRange(0x1A17, 0x1A18).addRange(0x1A58, 0x1A5E).addRange(0x1A65, 0x1A6C).addRange(0x1A73, 0x1A7C).addRange(0x1AB0, 0x1ABD).addRange(0x1ABF, 0x1ADD).addRange(0x1AE0, 0x1AEB).addRange(0x1B00, 0x1B03).addRange(0x1B36, 0x1B3A).addRange(0x1B6B, 0x1B73).addRange(0x1B80, 0x1B81).addRange(0x1BA2, 0x1BA5).addRange(0x1BA8, 0x1BA9).addRange(0x1BAB, 0x1BAD).addRange(0x1BE8, 0x1BE9).addRange(0x1BEF, 0x1BF1).addRange(0x1C2C, 0x1C33).addRange(0x1C36, 0x1C37).addRange(0x1CD0, 0x1CD2); +set.addRange(0x1CD4, 0x1CE0).addRange(0x1CE2, 0x1CE8).addRange(0x1CF8, 0x1CF9).addRange(0x1DC0, 0x1DFF).addRange(0x20D0, 0x20DC).addRange(0x20E5, 0x20F0).addRange(0x2CEF, 0x2CF1).addRange(0x2DE0, 0x2DFF).addRange(0x302A, 0x302D).addRange(0x3099, 0x309A).addRange(0xA674, 0xA67D).addRange(0xA69E, 0xA69F).addRange(0xA6F0, 0xA6F1).addRange(0xA825, 0xA826).addRange(0xA8C4, 0xA8C5).addRange(0xA8E0, 0xA8F1).addRange(0xA926, 0xA92D).addRange(0xA947, 0xA951).addRange(0xA980, 0xA982).addRange(0xA9B6, 0xA9B9).addRange(0xA9BC, 0xA9BD).addRange(0xAA29, 0xAA2E).addRange(0xAA31, 0xAA32).addRange(0xAA35, 0xAA36).addRange(0xAAB2, 0xAAB4).addRange(0xAAB7, 0xAAB8).addRange(0xAABE, 0xAABF).addRange(0xAAEC, 0xAAED).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2F).addRange(0x10376, 0x1037A).addRange(0x10A01, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A0F).addRange(0x10A38, 0x10A3A).addRange(0x10AE5, 0x10AE6).addRange(0x10D24, 0x10D27).addRange(0x10D69, 0x10D6D).addRange(0x10EAB, 0x10EAC).addRange(0x10EFA, 0x10EFF).addRange(0x10F46, 0x10F50).addRange(0x10F82, 0x10F85).addRange(0x11038, 0x11046).addRange(0x11073, 0x11074).addRange(0x1107F, 0x11081).addRange(0x110B3, 0x110B6).addRange(0x110B9, 0x110BA).addRange(0x11100, 0x11102).addRange(0x11127, 0x1112B).addRange(0x1112D, 0x11134).addRange(0x11180, 0x11181); +set.addRange(0x111B6, 0x111BE).addRange(0x111C9, 0x111CC).addRange(0x1122F, 0x11231).addRange(0x11236, 0x11237).addRange(0x112E3, 0x112EA).addRange(0x11300, 0x11301).addRange(0x1133B, 0x1133C).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x113BB, 0x113C0).addRange(0x113E1, 0x113E2).addRange(0x11438, 0x1143F).addRange(0x11442, 0x11444).addRange(0x114B3, 0x114B8).addRange(0x114BF, 0x114C0).addRange(0x114C2, 0x114C3).addRange(0x115B2, 0x115B5).addRange(0x115BC, 0x115BD).addRange(0x115BF, 0x115C0).addRange(0x115DC, 0x115DD).addRange(0x11633, 0x1163A).addRange(0x1163F, 0x11640).addRange(0x116B0, 0x116B5).addRange(0x11722, 0x11725).addRange(0x11727, 0x1172B).addRange(0x1182F, 0x11837).addRange(0x11839, 0x1183A).addRange(0x1193B, 0x1193C).addRange(0x119D4, 0x119D7).addRange(0x119DA, 0x119DB).addRange(0x11A01, 0x11A0A).addRange(0x11A33, 0x11A38).addRange(0x11A3B, 0x11A3E).addRange(0x11A51, 0x11A56).addRange(0x11A59, 0x11A5B).addRange(0x11A8A, 0x11A96).addRange(0x11A98, 0x11A99).addRange(0x11B62, 0x11B64).addRange(0x11C30, 0x11C36).addRange(0x11C38, 0x11C3D).addRange(0x11C92, 0x11CA7).addRange(0x11CAA, 0x11CB0).addRange(0x11CB2, 0x11CB3).addRange(0x11CB5, 0x11CB6).addRange(0x11D31, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D45).addRange(0x11D90, 0x11D91).addRange(0x11EF3, 0x11EF4).addRange(0x11F00, 0x11F01).addRange(0x11F36, 0x11F3A); +set.addRange(0x13447, 0x13455).addRange(0x1611E, 0x16129).addRange(0x1612D, 0x1612F).addRange(0x16AF0, 0x16AF4).addRange(0x16B30, 0x16B36).addRange(0x16F8F, 0x16F92).addRange(0x1BC9D, 0x1BC9E).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D167, 0x1D169).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1D242, 0x1D244).addRange(0x1DA00, 0x1DA36).addRange(0x1DA3B, 0x1DA6C).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E130, 0x1E136).addRange(0x1E2EC, 0x1E2EF).addRange(0x1E4EC, 0x1E4EF).addRange(0x1E5EE, 0x1E5EF).addRange(0x1E6EE, 0x1E6EF).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E944, 0x1E94A).addRange(0xE0100, 0xE01EF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Number.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Number.js new file mode 100644 index 0000000000000000000000000000000000000000..d0033aedc3bc72059dbdf5dfedabc9253d887e03 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Number.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0xB9, 0x2070, 0x2CFD, 0x3007, 0x10341, 0x1034A); +set.addRange(0x30, 0x39).addRange(0xB2, 0xB3).addRange(0xBC, 0xBE).addRange(0x660, 0x669).addRange(0x6F0, 0x6F9).addRange(0x7C0, 0x7C9).addRange(0x966, 0x96F).addRange(0x9E6, 0x9EF).addRange(0x9F4, 0x9F9).addRange(0xA66, 0xA6F).addRange(0xAE6, 0xAEF).addRange(0xB66, 0xB6F).addRange(0xB72, 0xB77).addRange(0xBE6, 0xBF2).addRange(0xC66, 0xC6F).addRange(0xC78, 0xC7E).addRange(0xCE6, 0xCEF).addRange(0xD58, 0xD5E).addRange(0xD66, 0xD78).addRange(0xDE6, 0xDEF).addRange(0xE50, 0xE59).addRange(0xED0, 0xED9).addRange(0xF20, 0xF33).addRange(0x1040, 0x1049).addRange(0x1090, 0x1099).addRange(0x1369, 0x137C).addRange(0x16EE, 0x16F0).addRange(0x17E0, 0x17E9).addRange(0x17F0, 0x17F9).addRange(0x1810, 0x1819).addRange(0x1946, 0x194F).addRange(0x19D0, 0x19DA).addRange(0x1A80, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1B50, 0x1B59).addRange(0x1BB0, 0x1BB9).addRange(0x1C40, 0x1C49).addRange(0x1C50, 0x1C59).addRange(0x2074, 0x2079).addRange(0x2080, 0x2089).addRange(0x2150, 0x2182).addRange(0x2185, 0x2189).addRange(0x2460, 0x249B).addRange(0x24EA, 0x24FF).addRange(0x2776, 0x2793).addRange(0x3021, 0x3029).addRange(0x3038, 0x303A).addRange(0x3192, 0x3195).addRange(0x3220, 0x3229).addRange(0x3248, 0x324F).addRange(0x3251, 0x325F); +set.addRange(0x3280, 0x3289).addRange(0x32B1, 0x32BF).addRange(0xA620, 0xA629).addRange(0xA6E6, 0xA6EF).addRange(0xA830, 0xA835).addRange(0xA8D0, 0xA8D9).addRange(0xA900, 0xA909).addRange(0xA9D0, 0xA9D9).addRange(0xA9F0, 0xA9F9).addRange(0xAA50, 0xAA59).addRange(0xABF0, 0xABF9).addRange(0xFF10, 0xFF19).addRange(0x10107, 0x10133).addRange(0x10140, 0x10178).addRange(0x1018A, 0x1018B).addRange(0x102E1, 0x102FB).addRange(0x10320, 0x10323).addRange(0x103D1, 0x103D5).addRange(0x104A0, 0x104A9).addRange(0x10858, 0x1085F).addRange(0x10879, 0x1087F).addRange(0x108A7, 0x108AF).addRange(0x108FB, 0x108FF).addRange(0x10916, 0x1091B).addRange(0x109BC, 0x109BD).addRange(0x109C0, 0x109CF).addRange(0x109D2, 0x109FF).addRange(0x10A40, 0x10A48).addRange(0x10A7D, 0x10A7E).addRange(0x10A9D, 0x10A9F).addRange(0x10AEB, 0x10AEF).addRange(0x10B58, 0x10B5F).addRange(0x10B78, 0x10B7F).addRange(0x10BA9, 0x10BAF).addRange(0x10CFA, 0x10CFF).addRange(0x10D30, 0x10D39).addRange(0x10D40, 0x10D49).addRange(0x10E60, 0x10E7E).addRange(0x10F1D, 0x10F26).addRange(0x10F51, 0x10F54).addRange(0x10FC5, 0x10FCB).addRange(0x11052, 0x1106F).addRange(0x110F0, 0x110F9).addRange(0x11136, 0x1113F).addRange(0x111D0, 0x111D9).addRange(0x111E1, 0x111F4).addRange(0x112F0, 0x112F9).addRange(0x11450, 0x11459).addRange(0x114D0, 0x114D9).addRange(0x11650, 0x11659).addRange(0x116C0, 0x116C9); +set.addRange(0x116D0, 0x116E3).addRange(0x11730, 0x1173B).addRange(0x118E0, 0x118F2).addRange(0x11950, 0x11959).addRange(0x11BF0, 0x11BF9).addRange(0x11C50, 0x11C6C).addRange(0x11D50, 0x11D59).addRange(0x11DA0, 0x11DA9).addRange(0x11DE0, 0x11DE9).addRange(0x11F50, 0x11F59).addRange(0x11FC0, 0x11FD4).addRange(0x12400, 0x1246E).addRange(0x16130, 0x16139).addRange(0x16A60, 0x16A69).addRange(0x16AC0, 0x16AC9).addRange(0x16B50, 0x16B59).addRange(0x16B5B, 0x16B61).addRange(0x16D70, 0x16D79).addRange(0x16E80, 0x16E96).addRange(0x16FF4, 0x16FF6).addRange(0x1CCF0, 0x1CCF9).addRange(0x1D2C0, 0x1D2D3).addRange(0x1D2E0, 0x1D2F3).addRange(0x1D360, 0x1D378).addRange(0x1D7CE, 0x1D7FF).addRange(0x1E140, 0x1E149).addRange(0x1E2F0, 0x1E2F9).addRange(0x1E4F0, 0x1E4F9).addRange(0x1E5F1, 0x1E5FA).addRange(0x1E8C7, 0x1E8CF).addRange(0x1E950, 0x1E959).addRange(0x1EC71, 0x1ECAB).addRange(0x1ECAD, 0x1ECAF).addRange(0x1ECB1, 0x1ECB4).addRange(0x1ED01, 0x1ED2D).addRange(0x1ED2F, 0x1ED3D).addRange(0x1F100, 0x1F10C).addRange(0x1FBF0, 0x1FBF9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Open_Punctuation.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Open_Punctuation.js new file mode 100644 index 0000000000000000000000000000000000000000..001180243275784f9fe200fea5e215a2f46ad132 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Open_Punctuation.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x28, 0x5B, 0x7B, 0xF3A, 0xF3C, 0x169B, 0x201A, 0x201E, 0x2045, 0x207D, 0x208D, 0x2308, 0x230A, 0x2329, 0x2768, 0x276A, 0x276C, 0x276E, 0x2770, 0x2772, 0x2774, 0x27C5, 0x27E6, 0x27E8, 0x27EA, 0x27EC, 0x27EE, 0x2983, 0x2985, 0x2987, 0x2989, 0x298B, 0x298D, 0x298F, 0x2991, 0x2993, 0x2995, 0x2997, 0x29D8, 0x29DA, 0x29FC, 0x2E22, 0x2E24, 0x2E26, 0x2E28, 0x2E42, 0x2E55, 0x2E57, 0x2E59, 0x2E5B, 0x3008, 0x300A, 0x300C, 0x300E, 0x3010, 0x3014, 0x3016, 0x3018, 0x301A, 0x301D, 0xFD3F, 0xFE17, 0xFE35, 0xFE37, 0xFE39, 0xFE3B, 0xFE3D, 0xFE3F, 0xFE41, 0xFE43, 0xFE47, 0xFE59, 0xFE5B, 0xFE5D, 0xFF08, 0xFF3B, 0xFF5B, 0xFF5F, 0xFF62); + +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other.js new file mode 100644 index 0000000000000000000000000000000000000000..5e84eddeb0821222da96420f9cc34b6312bcfeac --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other.js @@ -0,0 +1,12 @@ +const set = require('regenerate')(0xAD, 0x38B, 0x38D, 0x3A2, 0x530, 0x590, 0x61C, 0x6DD, 0x83F, 0x85F, 0x8E2, 0x984, 0x9A9, 0x9B1, 0x9DE, 0xA04, 0xA29, 0xA31, 0xA34, 0xA37, 0xA3D, 0xA5D, 0xA84, 0xA8E, 0xA92, 0xAA9, 0xAB1, 0xAB4, 0xAC6, 0xACA, 0xB00, 0xB04, 0xB29, 0xB31, 0xB34, 0xB5E, 0xB84, 0xB91, 0xB9B, 0xB9D, 0xBC9, 0xC0D, 0xC11, 0xC29, 0xC45, 0xC49, 0xC57, 0xC5B, 0xC8D, 0xC91, 0xCA9, 0xCB4, 0xCC5, 0xCC9, 0xCDF, 0xCF0, 0xD0D, 0xD11, 0xD45, 0xD49, 0xD80, 0xD84, 0xDB2, 0xDBC, 0xDD5, 0xDD7, 0xE83, 0xE85, 0xE8B, 0xEA4, 0xEA6, 0xEC5, 0xEC7, 0xECF, 0xF48, 0xF98, 0xFBD, 0xFCD, 0x10C6, 0x1249, 0x1257, 0x1259, 0x1289, 0x12B1, 0x12BF, 0x12C1, 0x12D7, 0x1311, 0x176D, 0x1771, 0x180E, 0x191F, 0x1A5F, 0x1B4D, 0x1F58, 0x1F5A, 0x1F5C, 0x1F5E, 0x1FB5, 0x1FC5, 0x1FDC, 0x1FF5, 0x1FFF, 0x208F, 0x2D26, 0x2DA7, 0x2DAF, 0x2DB7, 0x2DBF, 0x2DC7, 0x2DCF, 0x2DD7, 0x2DDF, 0x2E9A, 0x3040, 0x3130, 0x318F, 0x321F, 0xA9CE, 0xA9FF, 0xAB27, 0xAB2F, 0xFB37, 0xFB3D, 0xFB3F, 0xFB42, 0xFB45, 0xFE53, 0xFE67, 0xFE75, 0xFFE7, 0x1000C, 0x10027, 0x1003B, 0x1003E, 0x1018F, 0x1039E, 0x1057B, 0x1058B, 0x10593, 0x10596, 0x105A2, 0x105B2, 0x105BA, 0x10786, 0x107B1, 0x10809, 0x10836, 0x10856, 0x108F3, 0x10A04, 0x10A14, 0x10A18, 0x10E7F, 0x10EAA, 0x110BD, 0x11135, 0x111E0, 0x11212, 0x11287, 0x11289, 0x1128E, 0x1129E, 0x11304, 0x11329, 0x11331, 0x11334, 0x1133A, 0x1138A, 0x1138F, 0x113B6, 0x113C1, 0x113C6, 0x113CB, 0x113D6, 0x1145C, 0x11914, 0x11917, 0x11936, 0x11C09, 0x11C37, 0x11CA8, 0x11D07, 0x11D0A, 0x11D3B, 0x11D3E, 0x11D66, 0x11D69, 0x11D8F, 0x11D92, 0x11F11, 0x1246F, 0x16A5F, 0x16ABF, 0x16B5A, 0x16B62, 0x1AFF4, 0x1AFFC, 0x1AFFF, 0x1D455, 0x1D49D, 0x1D4AD, 0x1D4BA, 0x1D4BC, 0x1D4C4, 0x1D506, 0x1D515, 0x1D51D, 0x1D53A, 0x1D53F, 0x1D545, 0x1D551, 0x1DAA0, 0x1E007, 0x1E022, 0x1E025, 0x1E6DF, 0x1E7E7, 0x1E7EC, 0x1E7EF, 0x1E7FF, 0x1EE04, 0x1EE20, 0x1EE23, 0x1EE28, 0x1EE33, 0x1EE38, 0x1EE3A, 0x1EE48, 0x1EE4A, 0x1EE4C, 0x1EE50, 0x1EE53, 0x1EE58, 0x1EE5A, 0x1EE5C, 0x1EE5E, 0x1EE60, 0x1EE63, 0x1EE6B, 0x1EE73, 0x1EE78, 0x1EE7D, 0x1EE7F, 0x1EE8A, 0x1EEA4, 0x1EEAA, 0x1F0C0, 0x1F0D0, 0x1FAC7, 0x1FB93); +set.addRange(0x0, 0x1F).addRange(0x7F, 0x9F).addRange(0x378, 0x379).addRange(0x380, 0x383).addRange(0x557, 0x558).addRange(0x58B, 0x58C).addRange(0x5C8, 0x5CF).addRange(0x5EB, 0x5EE).addRange(0x5F5, 0x605).addRange(0x70E, 0x70F).addRange(0x74B, 0x74C).addRange(0x7B2, 0x7BF).addRange(0x7FB, 0x7FC).addRange(0x82E, 0x82F).addRange(0x85C, 0x85D).addRange(0x86B, 0x86F).addRange(0x890, 0x896).addRange(0x98D, 0x98E).addRange(0x991, 0x992).addRange(0x9B3, 0x9B5).addRange(0x9BA, 0x9BB).addRange(0x9C5, 0x9C6).addRange(0x9C9, 0x9CA).addRange(0x9CF, 0x9D6).addRange(0x9D8, 0x9DB).addRange(0x9E4, 0x9E5).addRange(0x9FF, 0xA00).addRange(0xA0B, 0xA0E).addRange(0xA11, 0xA12).addRange(0xA3A, 0xA3B).addRange(0xA43, 0xA46).addRange(0xA49, 0xA4A).addRange(0xA4E, 0xA50).addRange(0xA52, 0xA58).addRange(0xA5F, 0xA65).addRange(0xA77, 0xA80).addRange(0xABA, 0xABB).addRange(0xACE, 0xACF).addRange(0xAD1, 0xADF).addRange(0xAE4, 0xAE5).addRange(0xAF2, 0xAF8).addRange(0xB0D, 0xB0E).addRange(0xB11, 0xB12).addRange(0xB3A, 0xB3B).addRange(0xB45, 0xB46).addRange(0xB49, 0xB4A).addRange(0xB4E, 0xB54).addRange(0xB58, 0xB5B).addRange(0xB64, 0xB65).addRange(0xB78, 0xB81).addRange(0xB8B, 0xB8D); +set.addRange(0xB96, 0xB98).addRange(0xBA0, 0xBA2).addRange(0xBA5, 0xBA7).addRange(0xBAB, 0xBAD).addRange(0xBBA, 0xBBD).addRange(0xBC3, 0xBC5).addRange(0xBCE, 0xBCF).addRange(0xBD1, 0xBD6).addRange(0xBD8, 0xBE5).addRange(0xBFB, 0xBFF).addRange(0xC3A, 0xC3B).addRange(0xC4E, 0xC54).addRange(0xC5E, 0xC5F).addRange(0xC64, 0xC65).addRange(0xC70, 0xC76).addRange(0xCBA, 0xCBB).addRange(0xCCE, 0xCD4).addRange(0xCD7, 0xCDB).addRange(0xCE4, 0xCE5).addRange(0xCF4, 0xCFF).addRange(0xD50, 0xD53).addRange(0xD64, 0xD65).addRange(0xD97, 0xD99).addRange(0xDBE, 0xDBF).addRange(0xDC7, 0xDC9).addRange(0xDCB, 0xDCE).addRange(0xDE0, 0xDE5).addRange(0xDF0, 0xDF1).addRange(0xDF5, 0xE00).addRange(0xE3B, 0xE3E).addRange(0xE5C, 0xE80).addRange(0xEBE, 0xEBF).addRange(0xEDA, 0xEDB).addRange(0xEE0, 0xEFF).addRange(0xF6D, 0xF70).addRange(0xFDB, 0xFFF).addRange(0x10C8, 0x10CC).addRange(0x10CE, 0x10CF).addRange(0x124E, 0x124F).addRange(0x125E, 0x125F).addRange(0x128E, 0x128F).addRange(0x12B6, 0x12B7).addRange(0x12C6, 0x12C7).addRange(0x1316, 0x1317).addRange(0x135B, 0x135C).addRange(0x137D, 0x137F).addRange(0x139A, 0x139F).addRange(0x13F6, 0x13F7).addRange(0x13FE, 0x13FF).addRange(0x169D, 0x169F).addRange(0x16F9, 0x16FF); +set.addRange(0x1716, 0x171E).addRange(0x1737, 0x173F).addRange(0x1754, 0x175F).addRange(0x1774, 0x177F).addRange(0x17DE, 0x17DF).addRange(0x17EA, 0x17EF).addRange(0x17FA, 0x17FF).addRange(0x181A, 0x181F).addRange(0x1879, 0x187F).addRange(0x18AB, 0x18AF).addRange(0x18F6, 0x18FF).addRange(0x192C, 0x192F).addRange(0x193C, 0x193F).addRange(0x1941, 0x1943).addRange(0x196E, 0x196F).addRange(0x1975, 0x197F).addRange(0x19AC, 0x19AF).addRange(0x19CA, 0x19CF).addRange(0x19DB, 0x19DD).addRange(0x1A1C, 0x1A1D).addRange(0x1A7D, 0x1A7E).addRange(0x1A8A, 0x1A8F).addRange(0x1A9A, 0x1A9F).addRange(0x1AAE, 0x1AAF).addRange(0x1ADE, 0x1ADF).addRange(0x1AEC, 0x1AFF).addRange(0x1BF4, 0x1BFB).addRange(0x1C38, 0x1C3A).addRange(0x1C4A, 0x1C4C).addRange(0x1C8B, 0x1C8F).addRange(0x1CBB, 0x1CBC).addRange(0x1CC8, 0x1CCF).addRange(0x1CFB, 0x1CFF).addRange(0x1F16, 0x1F17).addRange(0x1F1E, 0x1F1F).addRange(0x1F46, 0x1F47).addRange(0x1F4E, 0x1F4F).addRange(0x1F7E, 0x1F7F).addRange(0x1FD4, 0x1FD5).addRange(0x1FF0, 0x1FF1).addRange(0x200B, 0x200F).addRange(0x202A, 0x202E).addRange(0x2060, 0x206F).addRange(0x2072, 0x2073).addRange(0x209D, 0x209F).addRange(0x20C2, 0x20CF).addRange(0x20F1, 0x20FF).addRange(0x218C, 0x218F).addRange(0x242A, 0x243F).addRange(0x244B, 0x245F).addRange(0x2B74, 0x2B75); +set.addRange(0x2CF4, 0x2CF8).addRange(0x2D28, 0x2D2C).addRange(0x2D2E, 0x2D2F).addRange(0x2D68, 0x2D6E).addRange(0x2D71, 0x2D7E).addRange(0x2D97, 0x2D9F).addRange(0x2E5E, 0x2E7F).addRange(0x2EF4, 0x2EFF).addRange(0x2FD6, 0x2FEF).addRange(0x3097, 0x3098).addRange(0x3100, 0x3104).addRange(0x31E6, 0x31EE).addRange(0xA48D, 0xA48F).addRange(0xA4C7, 0xA4CF).addRange(0xA62C, 0xA63F).addRange(0xA6F8, 0xA6FF).addRange(0xA7DD, 0xA7F0).addRange(0xA82D, 0xA82F).addRange(0xA83A, 0xA83F).addRange(0xA878, 0xA87F).addRange(0xA8C6, 0xA8CD).addRange(0xA8DA, 0xA8DF).addRange(0xA954, 0xA95E).addRange(0xA97D, 0xA97F).addRange(0xA9DA, 0xA9DD).addRange(0xAA37, 0xAA3F).addRange(0xAA4E, 0xAA4F).addRange(0xAA5A, 0xAA5B).addRange(0xAAC3, 0xAADA).addRange(0xAAF7, 0xAB00).addRange(0xAB07, 0xAB08).addRange(0xAB0F, 0xAB10).addRange(0xAB17, 0xAB1F).addRange(0xAB6C, 0xAB6F).addRange(0xABEE, 0xABEF).addRange(0xABFA, 0xABFF).addRange(0xD7A4, 0xD7AF).addRange(0xD7C7, 0xD7CA).addRange(0xD7FC, 0xF8FF).addRange(0xFA6E, 0xFA6F).addRange(0xFADA, 0xFAFF).addRange(0xFB07, 0xFB12).addRange(0xFB18, 0xFB1C).addRange(0xFDD0, 0xFDEF).addRange(0xFE1A, 0xFE1F).addRange(0xFE6C, 0xFE6F).addRange(0xFEFD, 0xFF00).addRange(0xFFBF, 0xFFC1).addRange(0xFFC8, 0xFFC9).addRange(0xFFD0, 0xFFD1).addRange(0xFFD8, 0xFFD9); +set.addRange(0xFFDD, 0xFFDF).addRange(0xFFEF, 0xFFFB).addRange(0xFFFE, 0xFFFF).addRange(0x1004E, 0x1004F).addRange(0x1005E, 0x1007F).addRange(0x100FB, 0x100FF).addRange(0x10103, 0x10106).addRange(0x10134, 0x10136).addRange(0x1019D, 0x1019F).addRange(0x101A1, 0x101CF).addRange(0x101FE, 0x1027F).addRange(0x1029D, 0x1029F).addRange(0x102D1, 0x102DF).addRange(0x102FC, 0x102FF).addRange(0x10324, 0x1032C).addRange(0x1034B, 0x1034F).addRange(0x1037B, 0x1037F).addRange(0x103C4, 0x103C7).addRange(0x103D6, 0x103FF).addRange(0x1049E, 0x1049F).addRange(0x104AA, 0x104AF).addRange(0x104D4, 0x104D7).addRange(0x104FC, 0x104FF).addRange(0x10528, 0x1052F).addRange(0x10564, 0x1056E).addRange(0x105BD, 0x105BF).addRange(0x105F4, 0x105FF).addRange(0x10737, 0x1073F).addRange(0x10756, 0x1075F).addRange(0x10768, 0x1077F).addRange(0x107BB, 0x107FF).addRange(0x10806, 0x10807).addRange(0x10839, 0x1083B).addRange(0x1083D, 0x1083E).addRange(0x1089F, 0x108A6).addRange(0x108B0, 0x108DF).addRange(0x108F6, 0x108FA).addRange(0x1091C, 0x1091E).addRange(0x1093A, 0x1093E).addRange(0x1095A, 0x1097F).addRange(0x109B8, 0x109BB).addRange(0x109D0, 0x109D1).addRange(0x10A07, 0x10A0B).addRange(0x10A36, 0x10A37).addRange(0x10A3B, 0x10A3E).addRange(0x10A49, 0x10A4F).addRange(0x10A59, 0x10A5F).addRange(0x10AA0, 0x10ABF).addRange(0x10AE7, 0x10AEA).addRange(0x10AF7, 0x10AFF).addRange(0x10B36, 0x10B38); +set.addRange(0x10B56, 0x10B57).addRange(0x10B73, 0x10B77).addRange(0x10B92, 0x10B98).addRange(0x10B9D, 0x10BA8).addRange(0x10BB0, 0x10BFF).addRange(0x10C49, 0x10C7F).addRange(0x10CB3, 0x10CBF).addRange(0x10CF3, 0x10CF9).addRange(0x10D28, 0x10D2F).addRange(0x10D3A, 0x10D3F).addRange(0x10D66, 0x10D68).addRange(0x10D86, 0x10D8D).addRange(0x10D90, 0x10E5F).addRange(0x10EAE, 0x10EAF).addRange(0x10EB2, 0x10EC1).addRange(0x10EC8, 0x10ECF).addRange(0x10ED9, 0x10EF9).addRange(0x10F28, 0x10F2F).addRange(0x10F5A, 0x10F6F).addRange(0x10F8A, 0x10FAF).addRange(0x10FCC, 0x10FDF).addRange(0x10FF7, 0x10FFF).addRange(0x1104E, 0x11051).addRange(0x11076, 0x1107E).addRange(0x110C3, 0x110CF).addRange(0x110E9, 0x110EF).addRange(0x110FA, 0x110FF).addRange(0x11148, 0x1114F).addRange(0x11177, 0x1117F).addRange(0x111F5, 0x111FF).addRange(0x11242, 0x1127F).addRange(0x112AA, 0x112AF).addRange(0x112EB, 0x112EF).addRange(0x112FA, 0x112FF).addRange(0x1130D, 0x1130E).addRange(0x11311, 0x11312).addRange(0x11345, 0x11346).addRange(0x11349, 0x1134A).addRange(0x1134E, 0x1134F).addRange(0x11351, 0x11356).addRange(0x11358, 0x1135C).addRange(0x11364, 0x11365).addRange(0x1136D, 0x1136F).addRange(0x11375, 0x1137F).addRange(0x1138C, 0x1138D).addRange(0x113C3, 0x113C4).addRange(0x113D9, 0x113E0).addRange(0x113E3, 0x113FF).addRange(0x11462, 0x1147F).addRange(0x114C8, 0x114CF).addRange(0x114DA, 0x1157F); +set.addRange(0x115B6, 0x115B7).addRange(0x115DE, 0x115FF).addRange(0x11645, 0x1164F).addRange(0x1165A, 0x1165F).addRange(0x1166D, 0x1167F).addRange(0x116BA, 0x116BF).addRange(0x116CA, 0x116CF).addRange(0x116E4, 0x116FF).addRange(0x1171B, 0x1171C).addRange(0x1172C, 0x1172F).addRange(0x11747, 0x117FF).addRange(0x1183C, 0x1189F).addRange(0x118F3, 0x118FE).addRange(0x11907, 0x11908).addRange(0x1190A, 0x1190B).addRange(0x11939, 0x1193A).addRange(0x11947, 0x1194F).addRange(0x1195A, 0x1199F).addRange(0x119A8, 0x119A9).addRange(0x119D8, 0x119D9).addRange(0x119E5, 0x119FF).addRange(0x11A48, 0x11A4F).addRange(0x11AA3, 0x11AAF).addRange(0x11AF9, 0x11AFF).addRange(0x11B0A, 0x11B5F).addRange(0x11B68, 0x11BBF).addRange(0x11BE2, 0x11BEF).addRange(0x11BFA, 0x11BFF).addRange(0x11C46, 0x11C4F).addRange(0x11C6D, 0x11C6F).addRange(0x11C90, 0x11C91).addRange(0x11CB7, 0x11CFF).addRange(0x11D37, 0x11D39).addRange(0x11D48, 0x11D4F).addRange(0x11D5A, 0x11D5F).addRange(0x11D99, 0x11D9F).addRange(0x11DAA, 0x11DAF).addRange(0x11DDC, 0x11DDF).addRange(0x11DEA, 0x11EDF).addRange(0x11EF9, 0x11EFF).addRange(0x11F3B, 0x11F3D).addRange(0x11F5B, 0x11FAF).addRange(0x11FB1, 0x11FBF).addRange(0x11FF2, 0x11FFE).addRange(0x1239A, 0x123FF).addRange(0x12475, 0x1247F).addRange(0x12544, 0x12F8F).addRange(0x12FF3, 0x12FFF).addRange(0x13430, 0x1343F).addRange(0x13456, 0x1345F).addRange(0x143FB, 0x143FF); +set.addRange(0x14647, 0x160FF).addRange(0x1613A, 0x167FF).addRange(0x16A39, 0x16A3F).addRange(0x16A6A, 0x16A6D).addRange(0x16ACA, 0x16ACF).addRange(0x16AEE, 0x16AEF).addRange(0x16AF6, 0x16AFF).addRange(0x16B46, 0x16B4F).addRange(0x16B78, 0x16B7C).addRange(0x16B90, 0x16D3F).addRange(0x16D7A, 0x16E3F).addRange(0x16E9B, 0x16E9F).addRange(0x16EB9, 0x16EBA).addRange(0x16ED4, 0x16EFF).addRange(0x16F4B, 0x16F4E).addRange(0x16F88, 0x16F8E).addRange(0x16FA0, 0x16FDF).addRange(0x16FE5, 0x16FEF).addRange(0x16FF7, 0x16FFF).addRange(0x18CD6, 0x18CFE).addRange(0x18D1F, 0x18D7F).addRange(0x18DF3, 0x1AFEF).addRange(0x1B123, 0x1B131).addRange(0x1B133, 0x1B14F).addRange(0x1B153, 0x1B154).addRange(0x1B156, 0x1B163).addRange(0x1B168, 0x1B16F).addRange(0x1B2FC, 0x1BBFF).addRange(0x1BC6B, 0x1BC6F).addRange(0x1BC7D, 0x1BC7F).addRange(0x1BC89, 0x1BC8F).addRange(0x1BC9A, 0x1BC9B).addRange(0x1BCA0, 0x1CBFF).addRange(0x1CCFD, 0x1CCFF).addRange(0x1CEB4, 0x1CEB9).addRange(0x1CED1, 0x1CEDF).addRange(0x1CEF1, 0x1CEFF).addRange(0x1CF2E, 0x1CF2F).addRange(0x1CF47, 0x1CF4F).addRange(0x1CFC4, 0x1CFFF).addRange(0x1D0F6, 0x1D0FF).addRange(0x1D127, 0x1D128).addRange(0x1D173, 0x1D17A).addRange(0x1D1EB, 0x1D1FF).addRange(0x1D246, 0x1D2BF).addRange(0x1D2D4, 0x1D2DF).addRange(0x1D2F4, 0x1D2FF).addRange(0x1D357, 0x1D35F).addRange(0x1D379, 0x1D3FF).addRange(0x1D4A0, 0x1D4A1).addRange(0x1D4A3, 0x1D4A4); +set.addRange(0x1D4A7, 0x1D4A8).addRange(0x1D50B, 0x1D50C).addRange(0x1D547, 0x1D549).addRange(0x1D6A6, 0x1D6A7).addRange(0x1D7CC, 0x1D7CD).addRange(0x1DA8C, 0x1DA9A).addRange(0x1DAB0, 0x1DEFF).addRange(0x1DF1F, 0x1DF24).addRange(0x1DF2B, 0x1DFFF).addRange(0x1E019, 0x1E01A).addRange(0x1E02B, 0x1E02F).addRange(0x1E06E, 0x1E08E).addRange(0x1E090, 0x1E0FF).addRange(0x1E12D, 0x1E12F).addRange(0x1E13E, 0x1E13F).addRange(0x1E14A, 0x1E14D).addRange(0x1E150, 0x1E28F).addRange(0x1E2AF, 0x1E2BF).addRange(0x1E2FA, 0x1E2FE).addRange(0x1E300, 0x1E4CF).addRange(0x1E4FA, 0x1E5CF).addRange(0x1E5FB, 0x1E5FE).addRange(0x1E600, 0x1E6BF).addRange(0x1E6F6, 0x1E6FD).addRange(0x1E700, 0x1E7DF).addRange(0x1E8C5, 0x1E8C6).addRange(0x1E8D7, 0x1E8FF).addRange(0x1E94C, 0x1E94F).addRange(0x1E95A, 0x1E95D).addRange(0x1E960, 0x1EC70).addRange(0x1ECB5, 0x1ED00).addRange(0x1ED3E, 0x1EDFF).addRange(0x1EE25, 0x1EE26).addRange(0x1EE3C, 0x1EE41).addRange(0x1EE43, 0x1EE46).addRange(0x1EE55, 0x1EE56).addRange(0x1EE65, 0x1EE66).addRange(0x1EE9C, 0x1EEA0).addRange(0x1EEBC, 0x1EEEF).addRange(0x1EEF2, 0x1EFFF).addRange(0x1F02C, 0x1F02F).addRange(0x1F094, 0x1F09F).addRange(0x1F0AF, 0x1F0B0).addRange(0x1F0F6, 0x1F0FF).addRange(0x1F1AE, 0x1F1E5).addRange(0x1F203, 0x1F20F).addRange(0x1F23C, 0x1F23F).addRange(0x1F249, 0x1F24F).addRange(0x1F252, 0x1F25F).addRange(0x1F266, 0x1F2FF).addRange(0x1F6D9, 0x1F6DB); +set.addRange(0x1F6ED, 0x1F6EF).addRange(0x1F6FD, 0x1F6FF).addRange(0x1F7DA, 0x1F7DF).addRange(0x1F7EC, 0x1F7EF).addRange(0x1F7F1, 0x1F7FF).addRange(0x1F80C, 0x1F80F).addRange(0x1F848, 0x1F84F).addRange(0x1F85A, 0x1F85F).addRange(0x1F888, 0x1F88F).addRange(0x1F8AE, 0x1F8AF).addRange(0x1F8BC, 0x1F8BF).addRange(0x1F8C2, 0x1F8CF).addRange(0x1F8D9, 0x1F8FF).addRange(0x1FA58, 0x1FA5F).addRange(0x1FA6E, 0x1FA6F).addRange(0x1FA7D, 0x1FA7F).addRange(0x1FA8B, 0x1FA8D).addRange(0x1FAC9, 0x1FACC).addRange(0x1FADD, 0x1FADE).addRange(0x1FAEB, 0x1FAEE).addRange(0x1FAF9, 0x1FAFF).addRange(0x1FBFB, 0x1FFFF).addRange(0x2A6E0, 0x2A6FF).addRange(0x2B81E, 0x2B81F).addRange(0x2CEAE, 0x2CEAF).addRange(0x2EBE1, 0x2EBEF).addRange(0x2EE5E, 0x2F7FF).addRange(0x2FA1E, 0x2FFFF).addRange(0x3134B, 0x3134F).addRange(0x3347A, 0xE00FF).addRange(0xE01F0, 0x10FFFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other_Letter.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other_Letter.js new file mode 100644 index 0000000000000000000000000000000000000000..7ad8060f1d1fe3321dee7e48ad7d0b467d593c87 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other_Letter.js @@ -0,0 +1,11 @@ +const set = require('regenerate')(0xAA, 0xBA, 0x1BB, 0x6D5, 0x6FF, 0x710, 0x7B1, 0x93D, 0x950, 0x9B2, 0x9BD, 0x9CE, 0x9FC, 0xA5E, 0xABD, 0xAD0, 0xAF9, 0xB3D, 0xB71, 0xB83, 0xB9C, 0xBD0, 0xC3D, 0xC80, 0xCBD, 0xD3D, 0xD4E, 0xDBD, 0xE84, 0xEA5, 0xEBD, 0xF00, 0x103F, 0x1061, 0x108E, 0x1258, 0x12C0, 0x17DC, 0x18AA, 0x1CFA, 0x3006, 0x303C, 0x309F, 0x30FF, 0xA66E, 0xA78F, 0xA7F7, 0xA8FB, 0xAA7A, 0xAAB1, 0xAAC0, 0xAAC2, 0xAAF2, 0xFB1D, 0xFB3E, 0x10808, 0x1083C, 0x10A00, 0x10D4F, 0x10F27, 0x11075, 0x11144, 0x11147, 0x11176, 0x111DA, 0x111DC, 0x11288, 0x1133D, 0x11350, 0x1138B, 0x1138E, 0x113B7, 0x113D1, 0x113D3, 0x114C7, 0x11644, 0x116B8, 0x11909, 0x1193F, 0x11941, 0x119E1, 0x119E3, 0x11A00, 0x11A3A, 0x11A50, 0x11A9D, 0x11C40, 0x11D46, 0x11D98, 0x11F02, 0x11FB0, 0x16F50, 0x1B132, 0x1B155, 0x1DF0A, 0x1E14E, 0x1E5F0, 0x1E6FE, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E); +set.addRange(0x1C0, 0x1C3).addRange(0x294, 0x295).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x620, 0x63F).addRange(0x641, 0x64A).addRange(0x66E, 0x66F).addRange(0x671, 0x6D3).addRange(0x6EE, 0x6EF).addRange(0x6FA, 0x6FC).addRange(0x712, 0x72F).addRange(0x74D, 0x7A5).addRange(0x7CA, 0x7EA).addRange(0x800, 0x815).addRange(0x840, 0x858).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88F).addRange(0x8A0, 0x8C8).addRange(0x904, 0x939).addRange(0x958, 0x961).addRange(0x972, 0x980).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E1).addRange(0x9F0, 0x9F1).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA59, 0xA5C).addRange(0xA72, 0xA74).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xAE0, 0xAE1).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33); +set.addRange(0xB35, 0xB39).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB61).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xC05, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC58, 0xC5A).addRange(0xC5C, 0xC5D).addRange(0xC60, 0xC61).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCDC, 0xCDE).addRange(0xCE0, 0xCE1).addRange(0xCF1, 0xCF2).addRange(0xD04, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD3A).addRange(0xD54, 0xD56).addRange(0xD5F, 0xD61).addRange(0xD7A, 0xD7F).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xE01, 0xE30).addRange(0xE32, 0xE33).addRange(0xE40, 0xE45).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEB0).addRange(0xEB2, 0xEB3).addRange(0xEC0, 0xEC4).addRange(0xEDC, 0xEDF).addRange(0xF40, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF88, 0xF8C).addRange(0x1000, 0x102A).addRange(0x1050, 0x1055); +set.addRange(0x105A, 0x105D).addRange(0x1065, 0x1066).addRange(0x106E, 0x1070).addRange(0x1075, 0x1081).addRange(0x1100, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x1380, 0x138F).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16F1, 0x16F8).addRange(0x1700, 0x1711).addRange(0x171F, 0x1731).addRange(0x1740, 0x1751).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1780, 0x17B3).addRange(0x1820, 0x1842).addRange(0x1844, 0x1878).addRange(0x1880, 0x1884).addRange(0x1887, 0x18A8).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1950, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x1A00, 0x1A16).addRange(0x1A20, 0x1A54).addRange(0x1B05, 0x1B33).addRange(0x1B45, 0x1B4C).addRange(0x1B83, 0x1BA0).addRange(0x1BAE, 0x1BAF).addRange(0x1BBA, 0x1BE5).addRange(0x1C00, 0x1C23).addRange(0x1C4D, 0x1C4F).addRange(0x1C5A, 0x1C77).addRange(0x1CE9, 0x1CEC); +set.addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF6).addRange(0x2135, 0x2138).addRange(0x2D30, 0x2D67).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x3041, 0x3096).addRange(0x30A1, 0x30FA).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA014).addRange(0xA016, 0xA48C).addRange(0xA4D0, 0xA4F7).addRange(0xA500, 0xA60B).addRange(0xA610, 0xA61F).addRange(0xA62A, 0xA62B).addRange(0xA6A0, 0xA6E5).addRange(0xA7FB, 0xA801).addRange(0xA803, 0xA805).addRange(0xA807, 0xA80A).addRange(0xA80C, 0xA822).addRange(0xA840, 0xA873).addRange(0xA882, 0xA8B3).addRange(0xA8F2, 0xA8F7).addRange(0xA8FD, 0xA8FE).addRange(0xA90A, 0xA925).addRange(0xA930, 0xA946).addRange(0xA960, 0xA97C).addRange(0xA984, 0xA9B2).addRange(0xA9E0, 0xA9E4).addRange(0xA9E7, 0xA9EF).addRange(0xA9FA, 0xA9FE).addRange(0xAA00, 0xAA28).addRange(0xAA40, 0xAA42).addRange(0xAA44, 0xAA4B).addRange(0xAA60, 0xAA6F).addRange(0xAA71, 0xAA76).addRange(0xAA7E, 0xAAAF).addRange(0xAAB5, 0xAAB6).addRange(0xAAB9, 0xAABD).addRange(0xAADB, 0xAADC); +set.addRange(0xAAE0, 0xAAEA).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xABC0, 0xABE2).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB1F, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFB).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF66, 0xFF6F).addRange(0xFF71, 0xFF9D).addRange(0xFFA0, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x10300, 0x1031F).addRange(0x1032D, 0x10340).addRange(0x10342, 0x10349).addRange(0x10350, 0x10375).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x10450, 0x1049D).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x105C0, 0x105F3); +set.addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915).addRange(0x10920, 0x10939).addRange(0x10940, 0x10959).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A10, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7).addRange(0x10AC9, 0x10AE4).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91).addRange(0x10C00, 0x10C48).addRange(0x10D00, 0x10D23).addRange(0x10D4A, 0x10D4D).addRange(0x10E80, 0x10EA9).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC4).addRange(0x10EC6, 0x10EC7).addRange(0x10F00, 0x10F1C).addRange(0x10F30, 0x10F45).addRange(0x10F70, 0x10F81).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11003, 0x11037).addRange(0x11071, 0x11072).addRange(0x11083, 0x110AF).addRange(0x110D0, 0x110E8).addRange(0x11103, 0x11126).addRange(0x11150, 0x11172).addRange(0x11183, 0x111B2).addRange(0x111C1, 0x111C4).addRange(0x11200, 0x11211).addRange(0x11213, 0x1122B).addRange(0x1123F, 0x11240).addRange(0x11280, 0x11286); +set.addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112DE).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1135D, 0x11361).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x11400, 0x11434).addRange(0x11447, 0x1144A).addRange(0x1145F, 0x11461).addRange(0x11480, 0x114AF).addRange(0x114C4, 0x114C5).addRange(0x11580, 0x115AE).addRange(0x115D8, 0x115DB).addRange(0x11600, 0x1162F).addRange(0x11680, 0x116AA).addRange(0x11700, 0x1171A).addRange(0x11740, 0x11746).addRange(0x11800, 0x1182B).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x1192F).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D0).addRange(0x11A0B, 0x11A32).addRange(0x11A5C, 0x11A89).addRange(0x11AB0, 0x11AF8).addRange(0x11BC0, 0x11BE0).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C2E).addRange(0x11C72, 0x11C8F).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D30).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D89).addRange(0x11DB0, 0x11DD8).addRange(0x11DDA, 0x11DDB).addRange(0x11EE0, 0x11EF2).addRange(0x11F04, 0x11F10).addRange(0x11F12, 0x11F33).addRange(0x12000, 0x12399).addRange(0x12480, 0x12543); +set.addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13441, 0x13446).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x1611D).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A70, 0x16ABE).addRange(0x16AD0, 0x16AED).addRange(0x16B00, 0x16B2F).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D43, 0x16D6A).addRange(0x16F00, 0x16F4A).addRange(0x17000, 0x18CD5).addRange(0x18CFF, 0x18D1E).addRange(0x18D80, 0x18DF2).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1E100, 0x1E12C).addRange(0x1E290, 0x1E2AD).addRange(0x1E2C0, 0x1E2EB).addRange(0x1E4D0, 0x1E4EA).addRange(0x1E5D0, 0x1E5ED).addRange(0x1E6C0, 0x1E6DE).addRange(0x1E6E0, 0x1E6E2).addRange(0x1E6E4, 0x1E6E5).addRange(0x1E6E7, 0x1E6ED).addRange(0x1E6F0, 0x1E6F4).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72); +set.addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other_Number.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other_Number.js new file mode 100644 index 0000000000000000000000000000000000000000..718f48fec9cc25767a8113f462b45f065833ea70 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other_Number.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0xB9, 0x19DA, 0x2070, 0x2189, 0x2CFD); +set.addRange(0xB2, 0xB3).addRange(0xBC, 0xBE).addRange(0x9F4, 0x9F9).addRange(0xB72, 0xB77).addRange(0xBF0, 0xBF2).addRange(0xC78, 0xC7E).addRange(0xD58, 0xD5E).addRange(0xD70, 0xD78).addRange(0xF2A, 0xF33).addRange(0x1369, 0x137C).addRange(0x17F0, 0x17F9).addRange(0x2074, 0x2079).addRange(0x2080, 0x2089).addRange(0x2150, 0x215F).addRange(0x2460, 0x249B).addRange(0x24EA, 0x24FF).addRange(0x2776, 0x2793).addRange(0x3192, 0x3195).addRange(0x3220, 0x3229).addRange(0x3248, 0x324F).addRange(0x3251, 0x325F).addRange(0x3280, 0x3289).addRange(0x32B1, 0x32BF).addRange(0xA830, 0xA835).addRange(0x10107, 0x10133).addRange(0x10175, 0x10178).addRange(0x1018A, 0x1018B).addRange(0x102E1, 0x102FB).addRange(0x10320, 0x10323).addRange(0x10858, 0x1085F).addRange(0x10879, 0x1087F).addRange(0x108A7, 0x108AF).addRange(0x108FB, 0x108FF).addRange(0x10916, 0x1091B).addRange(0x109BC, 0x109BD).addRange(0x109C0, 0x109CF).addRange(0x109D2, 0x109FF).addRange(0x10A40, 0x10A48).addRange(0x10A7D, 0x10A7E).addRange(0x10A9D, 0x10A9F).addRange(0x10AEB, 0x10AEF).addRange(0x10B58, 0x10B5F).addRange(0x10B78, 0x10B7F).addRange(0x10BA9, 0x10BAF).addRange(0x10CFA, 0x10CFF).addRange(0x10E60, 0x10E7E).addRange(0x10F1D, 0x10F26).addRange(0x10F51, 0x10F54).addRange(0x10FC5, 0x10FCB).addRange(0x11052, 0x11065).addRange(0x111E1, 0x111F4); +set.addRange(0x1173A, 0x1173B).addRange(0x118EA, 0x118F2).addRange(0x11C5A, 0x11C6C).addRange(0x11FC0, 0x11FD4).addRange(0x16B5B, 0x16B61).addRange(0x16E80, 0x16E96).addRange(0x1D2C0, 0x1D2D3).addRange(0x1D2E0, 0x1D2F3).addRange(0x1D360, 0x1D378).addRange(0x1E8C7, 0x1E8CF).addRange(0x1EC71, 0x1ECAB).addRange(0x1ECAD, 0x1ECAF).addRange(0x1ECB1, 0x1ECB4).addRange(0x1ED01, 0x1ED2D).addRange(0x1ED2F, 0x1ED3D).addRange(0x1F100, 0x1F10C); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other_Punctuation.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other_Punctuation.js new file mode 100644 index 0000000000000000000000000000000000000000..9bed13cf69390a90a52a428841a9e1cb08959b7c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other_Punctuation.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0x2A, 0x2C, 0x5C, 0xA1, 0xA7, 0xBF, 0x37E, 0x387, 0x589, 0x5C0, 0x5C3, 0x5C6, 0x61B, 0x6D4, 0x85E, 0x970, 0x9FD, 0xA76, 0xAF0, 0xC77, 0xC84, 0xDF4, 0xE4F, 0xF14, 0xF85, 0x10FB, 0x166E, 0x1CD3, 0x2053, 0x2D70, 0x2E0B, 0x2E1B, 0x2E41, 0x303D, 0x30FB, 0xA673, 0xA67E, 0xA8FC, 0xA95F, 0xABEB, 0xFE19, 0xFE30, 0xFE68, 0xFF0A, 0xFF0C, 0xFF3C, 0xFF61, 0x1039F, 0x103D0, 0x1056F, 0x10857, 0x1091F, 0x1093F, 0x10A7F, 0x10ED0, 0x111CD, 0x111DB, 0x112A9, 0x1145D, 0x114C6, 0x116B9, 0x1183B, 0x119E2, 0x11BE1, 0x11FFF, 0x16AF5, 0x16B44, 0x16FE2, 0x1BC9F, 0x1E5FF); +set.addRange(0x21, 0x23).addRange(0x25, 0x27).addRange(0x2E, 0x2F).addRange(0x3A, 0x3B).addRange(0x3F, 0x40).addRange(0xB6, 0xB7).addRange(0x55A, 0x55F).addRange(0x5F3, 0x5F4).addRange(0x609, 0x60A).addRange(0x60C, 0x60D).addRange(0x61D, 0x61F).addRange(0x66A, 0x66D).addRange(0x700, 0x70D).addRange(0x7F7, 0x7F9).addRange(0x830, 0x83E).addRange(0x964, 0x965).addRange(0xE5A, 0xE5B).addRange(0xF04, 0xF12).addRange(0xFD0, 0xFD4).addRange(0xFD9, 0xFDA).addRange(0x104A, 0x104F).addRange(0x1360, 0x1368).addRange(0x16EB, 0x16ED).addRange(0x1735, 0x1736).addRange(0x17D4, 0x17D6).addRange(0x17D8, 0x17DA).addRange(0x1800, 0x1805).addRange(0x1807, 0x180A).addRange(0x1944, 0x1945).addRange(0x1A1E, 0x1A1F).addRange(0x1AA0, 0x1AA6).addRange(0x1AA8, 0x1AAD).addRange(0x1B4E, 0x1B4F).addRange(0x1B5A, 0x1B60).addRange(0x1B7D, 0x1B7F).addRange(0x1BFC, 0x1BFF).addRange(0x1C3B, 0x1C3F).addRange(0x1C7E, 0x1C7F).addRange(0x1CC0, 0x1CC7).addRange(0x2016, 0x2017).addRange(0x2020, 0x2027).addRange(0x2030, 0x2038).addRange(0x203B, 0x203E).addRange(0x2041, 0x2043).addRange(0x2047, 0x2051).addRange(0x2055, 0x205E).addRange(0x2CF9, 0x2CFC).addRange(0x2CFE, 0x2CFF).addRange(0x2E00, 0x2E01).addRange(0x2E06, 0x2E08).addRange(0x2E0E, 0x2E16); +set.addRange(0x2E18, 0x2E19).addRange(0x2E1E, 0x2E1F).addRange(0x2E2A, 0x2E2E).addRange(0x2E30, 0x2E39).addRange(0x2E3C, 0x2E3F).addRange(0x2E43, 0x2E4F).addRange(0x2E52, 0x2E54).addRange(0x3001, 0x3003).addRange(0xA4FE, 0xA4FF).addRange(0xA60D, 0xA60F).addRange(0xA6F2, 0xA6F7).addRange(0xA874, 0xA877).addRange(0xA8CE, 0xA8CF).addRange(0xA8F8, 0xA8FA).addRange(0xA92E, 0xA92F).addRange(0xA9C1, 0xA9CD).addRange(0xA9DE, 0xA9DF).addRange(0xAA5C, 0xAA5F).addRange(0xAADE, 0xAADF).addRange(0xAAF0, 0xAAF1).addRange(0xFE10, 0xFE16).addRange(0xFE45, 0xFE46).addRange(0xFE49, 0xFE4C).addRange(0xFE50, 0xFE52).addRange(0xFE54, 0xFE57).addRange(0xFE5F, 0xFE61).addRange(0xFE6A, 0xFE6B).addRange(0xFF01, 0xFF03).addRange(0xFF05, 0xFF07).addRange(0xFF0E, 0xFF0F).addRange(0xFF1A, 0xFF1B).addRange(0xFF1F, 0xFF20).addRange(0xFF64, 0xFF65).addRange(0x10100, 0x10102).addRange(0x10A50, 0x10A58).addRange(0x10AF0, 0x10AF6).addRange(0x10B39, 0x10B3F).addRange(0x10B99, 0x10B9C).addRange(0x10F55, 0x10F59).addRange(0x10F86, 0x10F89).addRange(0x11047, 0x1104D).addRange(0x110BB, 0x110BC).addRange(0x110BE, 0x110C1).addRange(0x11140, 0x11143).addRange(0x11174, 0x11175).addRange(0x111C5, 0x111C8).addRange(0x111DD, 0x111DF).addRange(0x11238, 0x1123D).addRange(0x113D4, 0x113D5).addRange(0x113D7, 0x113D8).addRange(0x1144B, 0x1144F); +set.addRange(0x1145A, 0x1145B).addRange(0x115C1, 0x115D7).addRange(0x11641, 0x11643).addRange(0x11660, 0x1166C).addRange(0x1173C, 0x1173E).addRange(0x11944, 0x11946).addRange(0x11A3F, 0x11A46).addRange(0x11A9A, 0x11A9C).addRange(0x11A9E, 0x11AA2).addRange(0x11B00, 0x11B09).addRange(0x11C41, 0x11C45).addRange(0x11C70, 0x11C71).addRange(0x11EF7, 0x11EF8).addRange(0x11F43, 0x11F4F).addRange(0x12470, 0x12474).addRange(0x12FF1, 0x12FF2).addRange(0x16A6E, 0x16A6F).addRange(0x16B37, 0x16B3B).addRange(0x16D6D, 0x16D6F).addRange(0x16E97, 0x16E9A).addRange(0x1DA87, 0x1DA8B).addRange(0x1E95E, 0x1E95F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other_Symbol.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other_Symbol.js new file mode 100644 index 0000000000000000000000000000000000000000..94737a0087d5bd262213549f06e912be243b7dd0 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Other_Symbol.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0xA6, 0xA9, 0xAE, 0xB0, 0x482, 0x6DE, 0x6E9, 0x7F6, 0x9FA, 0xB70, 0xBFA, 0xC7F, 0xD4F, 0xD79, 0xF13, 0xF34, 0xF36, 0xF38, 0x166D, 0x1940, 0x2114, 0x2125, 0x2127, 0x2129, 0x212E, 0x214A, 0x214F, 0x21D3, 0x3004, 0x3020, 0x31EF, 0x3250, 0xA839, 0xFFE4, 0xFFE8, 0x101A0, 0x10AC8, 0x1173F, 0x16B45, 0x1BC9C, 0x1D245, 0x1E14F, 0x1ECAC, 0x1ED2E, 0x1F7F0, 0x1FAC8, 0x1FBFA); +set.addRange(0x58D, 0x58E).addRange(0x60E, 0x60F).addRange(0x6FD, 0x6FE).addRange(0xBF3, 0xBF8).addRange(0xF01, 0xF03).addRange(0xF15, 0xF17).addRange(0xF1A, 0xF1F).addRange(0xFBE, 0xFC5).addRange(0xFC7, 0xFCC).addRange(0xFCE, 0xFCF).addRange(0xFD5, 0xFD8).addRange(0x109E, 0x109F).addRange(0x1390, 0x1399).addRange(0x19DE, 0x19FF).addRange(0x1B61, 0x1B6A).addRange(0x1B74, 0x1B7C).addRange(0x2100, 0x2101).addRange(0x2103, 0x2106).addRange(0x2108, 0x2109).addRange(0x2116, 0x2117).addRange(0x211E, 0x2123).addRange(0x213A, 0x213B).addRange(0x214C, 0x214D).addRange(0x218A, 0x218B).addRange(0x2195, 0x2199).addRange(0x219C, 0x219F).addRange(0x21A1, 0x21A2).addRange(0x21A4, 0x21A5).addRange(0x21A7, 0x21AD).addRange(0x21AF, 0x21CD).addRange(0x21D0, 0x21D1).addRange(0x21D5, 0x21F3).addRange(0x2300, 0x2307).addRange(0x230C, 0x231F).addRange(0x2322, 0x2328).addRange(0x232B, 0x237B).addRange(0x237D, 0x239A).addRange(0x23B4, 0x23DB).addRange(0x23E2, 0x2429).addRange(0x2440, 0x244A).addRange(0x249C, 0x24E9).addRange(0x2500, 0x25B6).addRange(0x25B8, 0x25C0).addRange(0x25C2, 0x25F7).addRange(0x2600, 0x266E).addRange(0x2670, 0x2767).addRange(0x2794, 0x27BF).addRange(0x2800, 0x28FF).addRange(0x2B00, 0x2B2F).addRange(0x2B45, 0x2B46).addRange(0x2B4D, 0x2B73); +set.addRange(0x2B76, 0x2BFF).addRange(0x2CE5, 0x2CEA).addRange(0x2E50, 0x2E51).addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5).addRange(0x2FF0, 0x2FFF).addRange(0x3012, 0x3013).addRange(0x3036, 0x3037).addRange(0x303E, 0x303F).addRange(0x3190, 0x3191).addRange(0x3196, 0x319F).addRange(0x31C0, 0x31E5).addRange(0x3200, 0x321E).addRange(0x322A, 0x3247).addRange(0x3260, 0x327F).addRange(0x328A, 0x32B0).addRange(0x32C0, 0x33FF).addRange(0x4DC0, 0x4DFF).addRange(0xA490, 0xA4C6).addRange(0xA828, 0xA82B).addRange(0xA836, 0xA837).addRange(0xAA77, 0xAA79).addRange(0xFBC3, 0xFBD2).addRange(0xFD40, 0xFD4F).addRange(0xFD90, 0xFD91).addRange(0xFDC8, 0xFDCF).addRange(0xFDFD, 0xFDFF).addRange(0xFFED, 0xFFEE).addRange(0xFFFC, 0xFFFD).addRange(0x10137, 0x1013F).addRange(0x10179, 0x10189).addRange(0x1018C, 0x1018E).addRange(0x10190, 0x1019C).addRange(0x101D0, 0x101FC).addRange(0x10877, 0x10878).addRange(0x10ED1, 0x10ED8).addRange(0x11FD5, 0x11FDC).addRange(0x11FE1, 0x11FF1).addRange(0x16B3C, 0x16B3F).addRange(0x1CC00, 0x1CCEF).addRange(0x1CCFA, 0x1CCFC).addRange(0x1CD00, 0x1CEB3).addRange(0x1CEBA, 0x1CED0).addRange(0x1CEE0, 0x1CEEF).addRange(0x1CF50, 0x1CFC3).addRange(0x1D000, 0x1D0F5).addRange(0x1D100, 0x1D126).addRange(0x1D129, 0x1D164).addRange(0x1D16A, 0x1D16C).addRange(0x1D183, 0x1D184); +set.addRange(0x1D18C, 0x1D1A9).addRange(0x1D1AE, 0x1D1EA).addRange(0x1D200, 0x1D241).addRange(0x1D300, 0x1D356).addRange(0x1D800, 0x1D9FF).addRange(0x1DA37, 0x1DA3A).addRange(0x1DA6D, 0x1DA74).addRange(0x1DA76, 0x1DA83).addRange(0x1DA85, 0x1DA86).addRange(0x1F000, 0x1F02B).addRange(0x1F030, 0x1F093).addRange(0x1F0A0, 0x1F0AE).addRange(0x1F0B1, 0x1F0BF).addRange(0x1F0C1, 0x1F0CF).addRange(0x1F0D1, 0x1F0F5).addRange(0x1F10D, 0x1F1AD).addRange(0x1F1E6, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F250, 0x1F251).addRange(0x1F260, 0x1F265).addRange(0x1F300, 0x1F3FA).addRange(0x1F400, 0x1F6D8).addRange(0x1F6DC, 0x1F6EC).addRange(0x1F6F0, 0x1F6FC).addRange(0x1F700, 0x1F7D9).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F800, 0x1F80B).addRange(0x1F810, 0x1F847).addRange(0x1F850, 0x1F859).addRange(0x1F860, 0x1F887).addRange(0x1F890, 0x1F8AD).addRange(0x1F8B0, 0x1F8BB).addRange(0x1F8C0, 0x1F8C1).addRange(0x1F900, 0x1FA57).addRange(0x1FA60, 0x1FA6D).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA8A).addRange(0x1FA8E, 0x1FAC6).addRange(0x1FACD, 0x1FADC).addRange(0x1FADF, 0x1FAEA).addRange(0x1FAEF, 0x1FAF8).addRange(0x1FB00, 0x1FB92).addRange(0x1FB94, 0x1FBEF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Paragraph_Separator.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Paragraph_Separator.js new file mode 100644 index 0000000000000000000000000000000000000000..3120de91fd2fa82dd5cb238d8f5c4e4e918f294d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Paragraph_Separator.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2029); + +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Private_Use.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Private_Use.js new file mode 100644 index 0000000000000000000000000000000000000000..5bd107f5ea61e0702581d2e8d4c2e0807f3c0daf --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Private_Use.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xE000, 0xF8FF).addRange(0xF0000, 0xFFFFD).addRange(0x100000, 0x10FFFD); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Punctuation.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Punctuation.js new file mode 100644 index 0000000000000000000000000000000000000000..6e8e3d928540b0ba8af524c39c2899c29f675c36 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Punctuation.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0x5F, 0x7B, 0x7D, 0xA1, 0xA7, 0xAB, 0xBB, 0xBF, 0x37E, 0x387, 0x5BE, 0x5C0, 0x5C3, 0x5C6, 0x61B, 0x6D4, 0x85E, 0x970, 0x9FD, 0xA76, 0xAF0, 0xC77, 0xC84, 0xDF4, 0xE4F, 0xF14, 0xF85, 0x10FB, 0x1400, 0x166E, 0x1CD3, 0x2D70, 0x3030, 0x303D, 0x30A0, 0x30FB, 0xA673, 0xA67E, 0xA8FC, 0xA95F, 0xABEB, 0xFE63, 0xFE68, 0xFF3F, 0xFF5B, 0xFF5D, 0x1039F, 0x103D0, 0x1056F, 0x10857, 0x1091F, 0x1093F, 0x10A7F, 0x10D6E, 0x10EAD, 0x10ED0, 0x111CD, 0x111DB, 0x112A9, 0x1145D, 0x114C6, 0x116B9, 0x1183B, 0x119E2, 0x11BE1, 0x11FFF, 0x16AF5, 0x16B44, 0x16FE2, 0x1BC9F, 0x1E5FF); +set.addRange(0x21, 0x23).addRange(0x25, 0x2A).addRange(0x2C, 0x2F).addRange(0x3A, 0x3B).addRange(0x3F, 0x40).addRange(0x5B, 0x5D).addRange(0xB6, 0xB7).addRange(0x55A, 0x55F).addRange(0x589, 0x58A).addRange(0x5F3, 0x5F4).addRange(0x609, 0x60A).addRange(0x60C, 0x60D).addRange(0x61D, 0x61F).addRange(0x66A, 0x66D).addRange(0x700, 0x70D).addRange(0x7F7, 0x7F9).addRange(0x830, 0x83E).addRange(0x964, 0x965).addRange(0xE5A, 0xE5B).addRange(0xF04, 0xF12).addRange(0xF3A, 0xF3D).addRange(0xFD0, 0xFD4).addRange(0xFD9, 0xFDA).addRange(0x104A, 0x104F).addRange(0x1360, 0x1368).addRange(0x169B, 0x169C).addRange(0x16EB, 0x16ED).addRange(0x1735, 0x1736).addRange(0x17D4, 0x17D6).addRange(0x17D8, 0x17DA).addRange(0x1800, 0x180A).addRange(0x1944, 0x1945).addRange(0x1A1E, 0x1A1F).addRange(0x1AA0, 0x1AA6).addRange(0x1AA8, 0x1AAD).addRange(0x1B4E, 0x1B4F).addRange(0x1B5A, 0x1B60).addRange(0x1B7D, 0x1B7F).addRange(0x1BFC, 0x1BFF).addRange(0x1C3B, 0x1C3F).addRange(0x1C7E, 0x1C7F).addRange(0x1CC0, 0x1CC7).addRange(0x2010, 0x2027).addRange(0x2030, 0x2043).addRange(0x2045, 0x2051).addRange(0x2053, 0x205E).addRange(0x207D, 0x207E).addRange(0x208D, 0x208E).addRange(0x2308, 0x230B).addRange(0x2329, 0x232A).addRange(0x2768, 0x2775); +set.addRange(0x27C5, 0x27C6).addRange(0x27E6, 0x27EF).addRange(0x2983, 0x2998).addRange(0x29D8, 0x29DB).addRange(0x29FC, 0x29FD).addRange(0x2CF9, 0x2CFC).addRange(0x2CFE, 0x2CFF).addRange(0x2E00, 0x2E2E).addRange(0x2E30, 0x2E4F).addRange(0x2E52, 0x2E5D).addRange(0x3001, 0x3003).addRange(0x3008, 0x3011).addRange(0x3014, 0x301F).addRange(0xA4FE, 0xA4FF).addRange(0xA60D, 0xA60F).addRange(0xA6F2, 0xA6F7).addRange(0xA874, 0xA877).addRange(0xA8CE, 0xA8CF).addRange(0xA8F8, 0xA8FA).addRange(0xA92E, 0xA92F).addRange(0xA9C1, 0xA9CD).addRange(0xA9DE, 0xA9DF).addRange(0xAA5C, 0xAA5F).addRange(0xAADE, 0xAADF).addRange(0xAAF0, 0xAAF1).addRange(0xFD3E, 0xFD3F).addRange(0xFE10, 0xFE19).addRange(0xFE30, 0xFE52).addRange(0xFE54, 0xFE61).addRange(0xFE6A, 0xFE6B).addRange(0xFF01, 0xFF03).addRange(0xFF05, 0xFF0A).addRange(0xFF0C, 0xFF0F).addRange(0xFF1A, 0xFF1B).addRange(0xFF1F, 0xFF20).addRange(0xFF3B, 0xFF3D).addRange(0xFF5F, 0xFF65).addRange(0x10100, 0x10102).addRange(0x10A50, 0x10A58).addRange(0x10AF0, 0x10AF6).addRange(0x10B39, 0x10B3F).addRange(0x10B99, 0x10B9C).addRange(0x10F55, 0x10F59).addRange(0x10F86, 0x10F89).addRange(0x11047, 0x1104D).addRange(0x110BB, 0x110BC).addRange(0x110BE, 0x110C1).addRange(0x11140, 0x11143).addRange(0x11174, 0x11175).addRange(0x111C5, 0x111C8).addRange(0x111DD, 0x111DF); +set.addRange(0x11238, 0x1123D).addRange(0x113D4, 0x113D5).addRange(0x113D7, 0x113D8).addRange(0x1144B, 0x1144F).addRange(0x1145A, 0x1145B).addRange(0x115C1, 0x115D7).addRange(0x11641, 0x11643).addRange(0x11660, 0x1166C).addRange(0x1173C, 0x1173E).addRange(0x11944, 0x11946).addRange(0x11A3F, 0x11A46).addRange(0x11A9A, 0x11A9C).addRange(0x11A9E, 0x11AA2).addRange(0x11B00, 0x11B09).addRange(0x11C41, 0x11C45).addRange(0x11C70, 0x11C71).addRange(0x11EF7, 0x11EF8).addRange(0x11F43, 0x11F4F).addRange(0x12470, 0x12474).addRange(0x12FF1, 0x12FF2).addRange(0x16A6E, 0x16A6F).addRange(0x16B37, 0x16B3B).addRange(0x16D6D, 0x16D6F).addRange(0x16E97, 0x16E9A).addRange(0x1DA87, 0x1DA8B).addRange(0x1E95E, 0x1E95F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Separator.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Separator.js new file mode 100644 index 0000000000000000000000000000000000000000..995d7d6ed7ca7334c89a81c1c879930109a999db --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Separator.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000); +set.addRange(0x2000, 0x200A).addRange(0x2028, 0x2029); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Space_Separator.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Space_Separator.js new file mode 100644 index 0000000000000000000000000000000000000000..22e406f3376d7a2b12e0a3fadf730a40943f4ebd --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Space_Separator.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000); +set.addRange(0x2000, 0x200A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Spacing_Mark.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Spacing_Mark.js new file mode 100644 index 0000000000000000000000000000000000000000..409e4c11fac1e66aeef0f3a29c5a333885ec3e10 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Spacing_Mark.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0x903, 0x93B, 0x9D7, 0xA03, 0xA83, 0xAC9, 0xB3E, 0xB40, 0xB57, 0xBD7, 0xCBE, 0xCF3, 0xD57, 0xF7F, 0x1031, 0x1038, 0x108F, 0x1715, 0x1734, 0x17B6, 0x1A55, 0x1A57, 0x1A61, 0x1B04, 0x1B35, 0x1B3B, 0x1B82, 0x1BA1, 0x1BAA, 0x1BE7, 0x1BEE, 0x1CE1, 0x1CF7, 0xA827, 0xA983, 0xAA4D, 0xAA7B, 0xAA7D, 0xAAEB, 0xAAF5, 0xABEC, 0x11000, 0x11002, 0x11082, 0x1112C, 0x11182, 0x111CE, 0x11235, 0x11357, 0x113C2, 0x113C5, 0x113CF, 0x11445, 0x114B9, 0x114C1, 0x115BE, 0x1163E, 0x116AC, 0x116B6, 0x1171E, 0x11726, 0x11838, 0x1193D, 0x11940, 0x11942, 0x119E4, 0x11A39, 0x11A97, 0x11B61, 0x11B65, 0x11B67, 0x11C2F, 0x11C3E, 0x11CA9, 0x11CB1, 0x11CB4, 0x11D96, 0x11F03, 0x11F41); +set.addRange(0x93E, 0x940).addRange(0x949, 0x94C).addRange(0x94E, 0x94F).addRange(0x982, 0x983).addRange(0x9BE, 0x9C0).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CC).addRange(0xA3E, 0xA40).addRange(0xABE, 0xAC0).addRange(0xACB, 0xACC).addRange(0xB02, 0xB03).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4C).addRange(0xBBE, 0xBBF).addRange(0xBC1, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCC).addRange(0xC01, 0xC03).addRange(0xC41, 0xC44).addRange(0xC82, 0xC83).addRange(0xCC0, 0xCC4).addRange(0xCC7, 0xCC8).addRange(0xCCA, 0xCCB).addRange(0xCD5, 0xCD6).addRange(0xD02, 0xD03).addRange(0xD3E, 0xD40).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4C).addRange(0xD82, 0xD83).addRange(0xDCF, 0xDD1).addRange(0xDD8, 0xDDF).addRange(0xDF2, 0xDF3).addRange(0xF3E, 0xF3F).addRange(0x102B, 0x102C).addRange(0x103B, 0x103C).addRange(0x1056, 0x1057).addRange(0x1062, 0x1064).addRange(0x1067, 0x106D).addRange(0x1083, 0x1084).addRange(0x1087, 0x108C).addRange(0x109A, 0x109C).addRange(0x17BE, 0x17C5).addRange(0x17C7, 0x17C8).addRange(0x1923, 0x1926).addRange(0x1929, 0x192B).addRange(0x1930, 0x1931).addRange(0x1933, 0x1938).addRange(0x1A19, 0x1A1A).addRange(0x1A63, 0x1A64).addRange(0x1A6D, 0x1A72).addRange(0x1B3D, 0x1B41); +set.addRange(0x1B43, 0x1B44).addRange(0x1BA6, 0x1BA7).addRange(0x1BEA, 0x1BEC).addRange(0x1BF2, 0x1BF3).addRange(0x1C24, 0x1C2B).addRange(0x1C34, 0x1C35).addRange(0x302E, 0x302F).addRange(0xA823, 0xA824).addRange(0xA880, 0xA881).addRange(0xA8B4, 0xA8C3).addRange(0xA952, 0xA953).addRange(0xA9B4, 0xA9B5).addRange(0xA9BA, 0xA9BB).addRange(0xA9BE, 0xA9C0).addRange(0xAA2F, 0xAA30).addRange(0xAA33, 0xAA34).addRange(0xAAEE, 0xAAEF).addRange(0xABE3, 0xABE4).addRange(0xABE6, 0xABE7).addRange(0xABE9, 0xABEA).addRange(0x110B0, 0x110B2).addRange(0x110B7, 0x110B8).addRange(0x11145, 0x11146).addRange(0x111B3, 0x111B5).addRange(0x111BF, 0x111C0).addRange(0x1122C, 0x1122E).addRange(0x11232, 0x11233).addRange(0x112E0, 0x112E2).addRange(0x11302, 0x11303).addRange(0x1133E, 0x1133F).addRange(0x11341, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x11362, 0x11363).addRange(0x113B8, 0x113BA).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113CD).addRange(0x11435, 0x11437).addRange(0x11440, 0x11441).addRange(0x114B0, 0x114B2).addRange(0x114BB, 0x114BE).addRange(0x115AF, 0x115B1).addRange(0x115B8, 0x115BB).addRange(0x11630, 0x11632).addRange(0x1163B, 0x1163C).addRange(0x116AE, 0x116AF).addRange(0x11720, 0x11721).addRange(0x1182C, 0x1182E).addRange(0x11930, 0x11935).addRange(0x11937, 0x11938).addRange(0x119D1, 0x119D3); +set.addRange(0x119DC, 0x119DF).addRange(0x11A57, 0x11A58).addRange(0x11D8A, 0x11D8E).addRange(0x11D93, 0x11D94).addRange(0x11EF5, 0x11EF6).addRange(0x11F34, 0x11F35).addRange(0x11F3E, 0x11F3F).addRange(0x1612A, 0x1612C).addRange(0x16F51, 0x16F87).addRange(0x16FF0, 0x16FF1).addRange(0x1D165, 0x1D166).addRange(0x1D16D, 0x1D172); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Surrogate.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Surrogate.js new file mode 100644 index 0000000000000000000000000000000000000000..24eaf12e0640b3c9dfca5fdca04541a0e24912ad --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Surrogate.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xD800, 0xDFFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Symbol.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Symbol.js new file mode 100644 index 0000000000000000000000000000000000000000..8de3a9b7b80d190c4d042e2239991a17fec15dc3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Symbol.js @@ -0,0 +1,6 @@ +const set = require('regenerate')(0x24, 0x2B, 0x5E, 0x60, 0x7C, 0x7E, 0xAC, 0xB4, 0xB8, 0xD7, 0xF7, 0x2ED, 0x375, 0x3F6, 0x482, 0x60B, 0x6DE, 0x6E9, 0x7F6, 0x888, 0xAF1, 0xB70, 0xC7F, 0xD4F, 0xD79, 0xE3F, 0xF13, 0xF34, 0xF36, 0xF38, 0x166D, 0x17DB, 0x1940, 0x1FBD, 0x2044, 0x2052, 0x2114, 0x2125, 0x2127, 0x2129, 0x212E, 0x214F, 0x3004, 0x3020, 0x31EF, 0x3250, 0xAB5B, 0xFB29, 0xFE62, 0xFE69, 0xFF04, 0xFF0B, 0xFF3E, 0xFF40, 0xFF5C, 0xFF5E, 0x101A0, 0x10AC8, 0x1173F, 0x16B45, 0x1BC9C, 0x1D245, 0x1D6C1, 0x1D6DB, 0x1D6FB, 0x1D715, 0x1D735, 0x1D74F, 0x1D76F, 0x1D789, 0x1D7A9, 0x1D7C3, 0x1E14F, 0x1E2FF, 0x1ECAC, 0x1ECB0, 0x1ED2E, 0x1F7F0, 0x1FAC8, 0x1FBFA); +set.addRange(0x3C, 0x3E).addRange(0xA2, 0xA6).addRange(0xA8, 0xA9).addRange(0xAE, 0xB1).addRange(0x2C2, 0x2C5).addRange(0x2D2, 0x2DF).addRange(0x2E5, 0x2EB).addRange(0x2EF, 0x2FF).addRange(0x384, 0x385).addRange(0x58D, 0x58F).addRange(0x606, 0x608).addRange(0x60E, 0x60F).addRange(0x6FD, 0x6FE).addRange(0x7FE, 0x7FF).addRange(0x9F2, 0x9F3).addRange(0x9FA, 0x9FB).addRange(0xBF3, 0xBFA).addRange(0xF01, 0xF03).addRange(0xF15, 0xF17).addRange(0xF1A, 0xF1F).addRange(0xFBE, 0xFC5).addRange(0xFC7, 0xFCC).addRange(0xFCE, 0xFCF).addRange(0xFD5, 0xFD8).addRange(0x109E, 0x109F).addRange(0x1390, 0x1399).addRange(0x19DE, 0x19FF).addRange(0x1B61, 0x1B6A).addRange(0x1B74, 0x1B7C).addRange(0x1FBF, 0x1FC1).addRange(0x1FCD, 0x1FCF).addRange(0x1FDD, 0x1FDF).addRange(0x1FED, 0x1FEF).addRange(0x1FFD, 0x1FFE).addRange(0x207A, 0x207C).addRange(0x208A, 0x208C).addRange(0x20A0, 0x20C1).addRange(0x2100, 0x2101).addRange(0x2103, 0x2106).addRange(0x2108, 0x2109).addRange(0x2116, 0x2118).addRange(0x211E, 0x2123).addRange(0x213A, 0x213B).addRange(0x2140, 0x2144).addRange(0x214A, 0x214D).addRange(0x218A, 0x218B).addRange(0x2190, 0x2307).addRange(0x230C, 0x2328).addRange(0x232B, 0x2429).addRange(0x2440, 0x244A).addRange(0x249C, 0x24E9); +set.addRange(0x2500, 0x2767).addRange(0x2794, 0x27C4).addRange(0x27C7, 0x27E5).addRange(0x27F0, 0x2982).addRange(0x2999, 0x29D7).addRange(0x29DC, 0x29FB).addRange(0x29FE, 0x2B73).addRange(0x2B76, 0x2BFF).addRange(0x2CE5, 0x2CEA).addRange(0x2E50, 0x2E51).addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5).addRange(0x2FF0, 0x2FFF).addRange(0x3012, 0x3013).addRange(0x3036, 0x3037).addRange(0x303E, 0x303F).addRange(0x309B, 0x309C).addRange(0x3190, 0x3191).addRange(0x3196, 0x319F).addRange(0x31C0, 0x31E5).addRange(0x3200, 0x321E).addRange(0x322A, 0x3247).addRange(0x3260, 0x327F).addRange(0x328A, 0x32B0).addRange(0x32C0, 0x33FF).addRange(0x4DC0, 0x4DFF).addRange(0xA490, 0xA4C6).addRange(0xA700, 0xA716).addRange(0xA720, 0xA721).addRange(0xA789, 0xA78A).addRange(0xA828, 0xA82B).addRange(0xA836, 0xA839).addRange(0xAA77, 0xAA79).addRange(0xAB6A, 0xAB6B).addRange(0xFBB2, 0xFBD2).addRange(0xFD40, 0xFD4F).addRange(0xFD90, 0xFD91).addRange(0xFDC8, 0xFDCF).addRange(0xFDFC, 0xFDFF).addRange(0xFE64, 0xFE66).addRange(0xFF1C, 0xFF1E).addRange(0xFFE0, 0xFFE6).addRange(0xFFE8, 0xFFEE).addRange(0xFFFC, 0xFFFD).addRange(0x10137, 0x1013F).addRange(0x10179, 0x10189).addRange(0x1018C, 0x1018E).addRange(0x10190, 0x1019C).addRange(0x101D0, 0x101FC).addRange(0x10877, 0x10878); +set.addRange(0x10D8E, 0x10D8F).addRange(0x10ED1, 0x10ED8).addRange(0x11FD5, 0x11FF1).addRange(0x16B3C, 0x16B3F).addRange(0x1CC00, 0x1CCEF).addRange(0x1CCFA, 0x1CCFC).addRange(0x1CD00, 0x1CEB3).addRange(0x1CEBA, 0x1CED0).addRange(0x1CEE0, 0x1CEF0).addRange(0x1CF50, 0x1CFC3).addRange(0x1D000, 0x1D0F5).addRange(0x1D100, 0x1D126).addRange(0x1D129, 0x1D164).addRange(0x1D16A, 0x1D16C).addRange(0x1D183, 0x1D184).addRange(0x1D18C, 0x1D1A9).addRange(0x1D1AE, 0x1D1EA).addRange(0x1D200, 0x1D241).addRange(0x1D300, 0x1D356).addRange(0x1D800, 0x1D9FF).addRange(0x1DA37, 0x1DA3A).addRange(0x1DA6D, 0x1DA74).addRange(0x1DA76, 0x1DA83).addRange(0x1DA85, 0x1DA86).addRange(0x1EEF0, 0x1EEF1).addRange(0x1F000, 0x1F02B).addRange(0x1F030, 0x1F093).addRange(0x1F0A0, 0x1F0AE).addRange(0x1F0B1, 0x1F0BF).addRange(0x1F0C1, 0x1F0CF).addRange(0x1F0D1, 0x1F0F5).addRange(0x1F10D, 0x1F1AD).addRange(0x1F1E6, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F250, 0x1F251).addRange(0x1F260, 0x1F265).addRange(0x1F300, 0x1F6D8).addRange(0x1F6DC, 0x1F6EC).addRange(0x1F6F0, 0x1F6FC).addRange(0x1F700, 0x1F7D9).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F800, 0x1F80B).addRange(0x1F810, 0x1F847).addRange(0x1F850, 0x1F859).addRange(0x1F860, 0x1F887).addRange(0x1F890, 0x1F8AD).addRange(0x1F8B0, 0x1F8BB).addRange(0x1F8C0, 0x1F8C1).addRange(0x1F8D0, 0x1F8D8).addRange(0x1F900, 0x1FA57); +set.addRange(0x1FA60, 0x1FA6D).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA8A).addRange(0x1FA8E, 0x1FAC6).addRange(0x1FACD, 0x1FADC).addRange(0x1FADF, 0x1FAEA).addRange(0x1FAEF, 0x1FAF8).addRange(0x1FB00, 0x1FB92).addRange(0x1FB94, 0x1FBEF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Titlecase_Letter.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Titlecase_Letter.js new file mode 100644 index 0000000000000000000000000000000000000000..f77be9cb5cdb938c5e07002b2efcca86a51263ec --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Titlecase_Letter.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1C5, 0x1C8, 0x1CB, 0x1F2, 0x1FBC, 0x1FCC, 0x1FFC); +set.addRange(0x1F88, 0x1F8F).addRange(0x1F98, 0x1F9F).addRange(0x1FA8, 0x1FAF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Unassigned.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Unassigned.js new file mode 100644 index 0000000000000000000000000000000000000000..f108dfdfd970f0107b742e79efad839e7b7e1afb --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Unassigned.js @@ -0,0 +1,12 @@ +const set = require('regenerate')(0x38B, 0x38D, 0x3A2, 0x530, 0x590, 0x70E, 0x83F, 0x85F, 0x984, 0x9A9, 0x9B1, 0x9DE, 0xA04, 0xA29, 0xA31, 0xA34, 0xA37, 0xA3D, 0xA5D, 0xA84, 0xA8E, 0xA92, 0xAA9, 0xAB1, 0xAB4, 0xAC6, 0xACA, 0xB00, 0xB04, 0xB29, 0xB31, 0xB34, 0xB5E, 0xB84, 0xB91, 0xB9B, 0xB9D, 0xBC9, 0xC0D, 0xC11, 0xC29, 0xC45, 0xC49, 0xC57, 0xC5B, 0xC8D, 0xC91, 0xCA9, 0xCB4, 0xCC5, 0xCC9, 0xCDF, 0xCF0, 0xD0D, 0xD11, 0xD45, 0xD49, 0xD80, 0xD84, 0xDB2, 0xDBC, 0xDD5, 0xDD7, 0xE83, 0xE85, 0xE8B, 0xEA4, 0xEA6, 0xEC5, 0xEC7, 0xECF, 0xF48, 0xF98, 0xFBD, 0xFCD, 0x10C6, 0x1249, 0x1257, 0x1259, 0x1289, 0x12B1, 0x12BF, 0x12C1, 0x12D7, 0x1311, 0x176D, 0x1771, 0x191F, 0x1A5F, 0x1B4D, 0x1F58, 0x1F5A, 0x1F5C, 0x1F5E, 0x1FB5, 0x1FC5, 0x1FDC, 0x1FF5, 0x1FFF, 0x2065, 0x208F, 0x2D26, 0x2DA7, 0x2DAF, 0x2DB7, 0x2DBF, 0x2DC7, 0x2DCF, 0x2DD7, 0x2DDF, 0x2E9A, 0x3040, 0x3130, 0x318F, 0x321F, 0xA9CE, 0xA9FF, 0xAB27, 0xAB2F, 0xFB37, 0xFB3D, 0xFB3F, 0xFB42, 0xFB45, 0xFE53, 0xFE67, 0xFE75, 0xFF00, 0xFFE7, 0x1000C, 0x10027, 0x1003B, 0x1003E, 0x1018F, 0x1039E, 0x1057B, 0x1058B, 0x10593, 0x10596, 0x105A2, 0x105B2, 0x105BA, 0x10786, 0x107B1, 0x10809, 0x10836, 0x10856, 0x108F3, 0x10A04, 0x10A14, 0x10A18, 0x10E7F, 0x10EAA, 0x11135, 0x111E0, 0x11212, 0x11287, 0x11289, 0x1128E, 0x1129E, 0x11304, 0x11329, 0x11331, 0x11334, 0x1133A, 0x1138A, 0x1138F, 0x113B6, 0x113C1, 0x113C6, 0x113CB, 0x113D6, 0x1145C, 0x11914, 0x11917, 0x11936, 0x11C09, 0x11C37, 0x11CA8, 0x11D07, 0x11D0A, 0x11D3B, 0x11D3E, 0x11D66, 0x11D69, 0x11D8F, 0x11D92, 0x11F11, 0x1246F, 0x16A5F, 0x16ABF, 0x16B5A, 0x16B62, 0x1AFF4, 0x1AFFC, 0x1AFFF, 0x1D455, 0x1D49D, 0x1D4AD, 0x1D4BA, 0x1D4BC, 0x1D4C4, 0x1D506, 0x1D515, 0x1D51D, 0x1D53A, 0x1D53F, 0x1D545, 0x1D551, 0x1DAA0, 0x1E007, 0x1E022, 0x1E025, 0x1E6DF, 0x1E7E7, 0x1E7EC, 0x1E7EF, 0x1E7FF, 0x1EE04, 0x1EE20, 0x1EE23, 0x1EE28, 0x1EE33, 0x1EE38, 0x1EE3A, 0x1EE48, 0x1EE4A, 0x1EE4C, 0x1EE50, 0x1EE53, 0x1EE58, 0x1EE5A, 0x1EE5C, 0x1EE5E, 0x1EE60, 0x1EE63, 0x1EE6B, 0x1EE73, 0x1EE78, 0x1EE7D, 0x1EE7F, 0x1EE8A, 0x1EEA4, 0x1EEAA, 0x1F0C0, 0x1F0D0, 0x1FAC7, 0x1FB93); +set.addRange(0x378, 0x379).addRange(0x380, 0x383).addRange(0x557, 0x558).addRange(0x58B, 0x58C).addRange(0x5C8, 0x5CF).addRange(0x5EB, 0x5EE).addRange(0x5F5, 0x5FF).addRange(0x74B, 0x74C).addRange(0x7B2, 0x7BF).addRange(0x7FB, 0x7FC).addRange(0x82E, 0x82F).addRange(0x85C, 0x85D).addRange(0x86B, 0x86F).addRange(0x892, 0x896).addRange(0x98D, 0x98E).addRange(0x991, 0x992).addRange(0x9B3, 0x9B5).addRange(0x9BA, 0x9BB).addRange(0x9C5, 0x9C6).addRange(0x9C9, 0x9CA).addRange(0x9CF, 0x9D6).addRange(0x9D8, 0x9DB).addRange(0x9E4, 0x9E5).addRange(0x9FF, 0xA00).addRange(0xA0B, 0xA0E).addRange(0xA11, 0xA12).addRange(0xA3A, 0xA3B).addRange(0xA43, 0xA46).addRange(0xA49, 0xA4A).addRange(0xA4E, 0xA50).addRange(0xA52, 0xA58).addRange(0xA5F, 0xA65).addRange(0xA77, 0xA80).addRange(0xABA, 0xABB).addRange(0xACE, 0xACF).addRange(0xAD1, 0xADF).addRange(0xAE4, 0xAE5).addRange(0xAF2, 0xAF8).addRange(0xB0D, 0xB0E).addRange(0xB11, 0xB12).addRange(0xB3A, 0xB3B).addRange(0xB45, 0xB46).addRange(0xB49, 0xB4A).addRange(0xB4E, 0xB54).addRange(0xB58, 0xB5B).addRange(0xB64, 0xB65).addRange(0xB78, 0xB81).addRange(0xB8B, 0xB8D).addRange(0xB96, 0xB98).addRange(0xBA0, 0xBA2).addRange(0xBA5, 0xBA7); +set.addRange(0xBAB, 0xBAD).addRange(0xBBA, 0xBBD).addRange(0xBC3, 0xBC5).addRange(0xBCE, 0xBCF).addRange(0xBD1, 0xBD6).addRange(0xBD8, 0xBE5).addRange(0xBFB, 0xBFF).addRange(0xC3A, 0xC3B).addRange(0xC4E, 0xC54).addRange(0xC5E, 0xC5F).addRange(0xC64, 0xC65).addRange(0xC70, 0xC76).addRange(0xCBA, 0xCBB).addRange(0xCCE, 0xCD4).addRange(0xCD7, 0xCDB).addRange(0xCE4, 0xCE5).addRange(0xCF4, 0xCFF).addRange(0xD50, 0xD53).addRange(0xD64, 0xD65).addRange(0xD97, 0xD99).addRange(0xDBE, 0xDBF).addRange(0xDC7, 0xDC9).addRange(0xDCB, 0xDCE).addRange(0xDE0, 0xDE5).addRange(0xDF0, 0xDF1).addRange(0xDF5, 0xE00).addRange(0xE3B, 0xE3E).addRange(0xE5C, 0xE80).addRange(0xEBE, 0xEBF).addRange(0xEDA, 0xEDB).addRange(0xEE0, 0xEFF).addRange(0xF6D, 0xF70).addRange(0xFDB, 0xFFF).addRange(0x10C8, 0x10CC).addRange(0x10CE, 0x10CF).addRange(0x124E, 0x124F).addRange(0x125E, 0x125F).addRange(0x128E, 0x128F).addRange(0x12B6, 0x12B7).addRange(0x12C6, 0x12C7).addRange(0x1316, 0x1317).addRange(0x135B, 0x135C).addRange(0x137D, 0x137F).addRange(0x139A, 0x139F).addRange(0x13F6, 0x13F7).addRange(0x13FE, 0x13FF).addRange(0x169D, 0x169F).addRange(0x16F9, 0x16FF).addRange(0x1716, 0x171E).addRange(0x1737, 0x173F).addRange(0x1754, 0x175F); +set.addRange(0x1774, 0x177F).addRange(0x17DE, 0x17DF).addRange(0x17EA, 0x17EF).addRange(0x17FA, 0x17FF).addRange(0x181A, 0x181F).addRange(0x1879, 0x187F).addRange(0x18AB, 0x18AF).addRange(0x18F6, 0x18FF).addRange(0x192C, 0x192F).addRange(0x193C, 0x193F).addRange(0x1941, 0x1943).addRange(0x196E, 0x196F).addRange(0x1975, 0x197F).addRange(0x19AC, 0x19AF).addRange(0x19CA, 0x19CF).addRange(0x19DB, 0x19DD).addRange(0x1A1C, 0x1A1D).addRange(0x1A7D, 0x1A7E).addRange(0x1A8A, 0x1A8F).addRange(0x1A9A, 0x1A9F).addRange(0x1AAE, 0x1AAF).addRange(0x1ADE, 0x1ADF).addRange(0x1AEC, 0x1AFF).addRange(0x1BF4, 0x1BFB).addRange(0x1C38, 0x1C3A).addRange(0x1C4A, 0x1C4C).addRange(0x1C8B, 0x1C8F).addRange(0x1CBB, 0x1CBC).addRange(0x1CC8, 0x1CCF).addRange(0x1CFB, 0x1CFF).addRange(0x1F16, 0x1F17).addRange(0x1F1E, 0x1F1F).addRange(0x1F46, 0x1F47).addRange(0x1F4E, 0x1F4F).addRange(0x1F7E, 0x1F7F).addRange(0x1FD4, 0x1FD5).addRange(0x1FF0, 0x1FF1).addRange(0x2072, 0x2073).addRange(0x209D, 0x209F).addRange(0x20C2, 0x20CF).addRange(0x20F1, 0x20FF).addRange(0x218C, 0x218F).addRange(0x242A, 0x243F).addRange(0x244B, 0x245F).addRange(0x2B74, 0x2B75).addRange(0x2CF4, 0x2CF8).addRange(0x2D28, 0x2D2C).addRange(0x2D2E, 0x2D2F).addRange(0x2D68, 0x2D6E).addRange(0x2D71, 0x2D7E).addRange(0x2D97, 0x2D9F); +set.addRange(0x2E5E, 0x2E7F).addRange(0x2EF4, 0x2EFF).addRange(0x2FD6, 0x2FEF).addRange(0x3097, 0x3098).addRange(0x3100, 0x3104).addRange(0x31E6, 0x31EE).addRange(0xA48D, 0xA48F).addRange(0xA4C7, 0xA4CF).addRange(0xA62C, 0xA63F).addRange(0xA6F8, 0xA6FF).addRange(0xA7DD, 0xA7F0).addRange(0xA82D, 0xA82F).addRange(0xA83A, 0xA83F).addRange(0xA878, 0xA87F).addRange(0xA8C6, 0xA8CD).addRange(0xA8DA, 0xA8DF).addRange(0xA954, 0xA95E).addRange(0xA97D, 0xA97F).addRange(0xA9DA, 0xA9DD).addRange(0xAA37, 0xAA3F).addRange(0xAA4E, 0xAA4F).addRange(0xAA5A, 0xAA5B).addRange(0xAAC3, 0xAADA).addRange(0xAAF7, 0xAB00).addRange(0xAB07, 0xAB08).addRange(0xAB0F, 0xAB10).addRange(0xAB17, 0xAB1F).addRange(0xAB6C, 0xAB6F).addRange(0xABEE, 0xABEF).addRange(0xABFA, 0xABFF).addRange(0xD7A4, 0xD7AF).addRange(0xD7C7, 0xD7CA).addRange(0xD7FC, 0xD7FF).addRange(0xFA6E, 0xFA6F).addRange(0xFADA, 0xFAFF).addRange(0xFB07, 0xFB12).addRange(0xFB18, 0xFB1C).addRange(0xFDD0, 0xFDEF).addRange(0xFE1A, 0xFE1F).addRange(0xFE6C, 0xFE6F).addRange(0xFEFD, 0xFEFE).addRange(0xFFBF, 0xFFC1).addRange(0xFFC8, 0xFFC9).addRange(0xFFD0, 0xFFD1).addRange(0xFFD8, 0xFFD9).addRange(0xFFDD, 0xFFDF).addRange(0xFFEF, 0xFFF8).addRange(0xFFFE, 0xFFFF).addRange(0x1004E, 0x1004F).addRange(0x1005E, 0x1007F).addRange(0x100FB, 0x100FF); +set.addRange(0x10103, 0x10106).addRange(0x10134, 0x10136).addRange(0x1019D, 0x1019F).addRange(0x101A1, 0x101CF).addRange(0x101FE, 0x1027F).addRange(0x1029D, 0x1029F).addRange(0x102D1, 0x102DF).addRange(0x102FC, 0x102FF).addRange(0x10324, 0x1032C).addRange(0x1034B, 0x1034F).addRange(0x1037B, 0x1037F).addRange(0x103C4, 0x103C7).addRange(0x103D6, 0x103FF).addRange(0x1049E, 0x1049F).addRange(0x104AA, 0x104AF).addRange(0x104D4, 0x104D7).addRange(0x104FC, 0x104FF).addRange(0x10528, 0x1052F).addRange(0x10564, 0x1056E).addRange(0x105BD, 0x105BF).addRange(0x105F4, 0x105FF).addRange(0x10737, 0x1073F).addRange(0x10756, 0x1075F).addRange(0x10768, 0x1077F).addRange(0x107BB, 0x107FF).addRange(0x10806, 0x10807).addRange(0x10839, 0x1083B).addRange(0x1083D, 0x1083E).addRange(0x1089F, 0x108A6).addRange(0x108B0, 0x108DF).addRange(0x108F6, 0x108FA).addRange(0x1091C, 0x1091E).addRange(0x1093A, 0x1093E).addRange(0x1095A, 0x1097F).addRange(0x109B8, 0x109BB).addRange(0x109D0, 0x109D1).addRange(0x10A07, 0x10A0B).addRange(0x10A36, 0x10A37).addRange(0x10A3B, 0x10A3E).addRange(0x10A49, 0x10A4F).addRange(0x10A59, 0x10A5F).addRange(0x10AA0, 0x10ABF).addRange(0x10AE7, 0x10AEA).addRange(0x10AF7, 0x10AFF).addRange(0x10B36, 0x10B38).addRange(0x10B56, 0x10B57).addRange(0x10B73, 0x10B77).addRange(0x10B92, 0x10B98).addRange(0x10B9D, 0x10BA8).addRange(0x10BB0, 0x10BFF).addRange(0x10C49, 0x10C7F); +set.addRange(0x10CB3, 0x10CBF).addRange(0x10CF3, 0x10CF9).addRange(0x10D28, 0x10D2F).addRange(0x10D3A, 0x10D3F).addRange(0x10D66, 0x10D68).addRange(0x10D86, 0x10D8D).addRange(0x10D90, 0x10E5F).addRange(0x10EAE, 0x10EAF).addRange(0x10EB2, 0x10EC1).addRange(0x10EC8, 0x10ECF).addRange(0x10ED9, 0x10EF9).addRange(0x10F28, 0x10F2F).addRange(0x10F5A, 0x10F6F).addRange(0x10F8A, 0x10FAF).addRange(0x10FCC, 0x10FDF).addRange(0x10FF7, 0x10FFF).addRange(0x1104E, 0x11051).addRange(0x11076, 0x1107E).addRange(0x110C3, 0x110CC).addRange(0x110CE, 0x110CF).addRange(0x110E9, 0x110EF).addRange(0x110FA, 0x110FF).addRange(0x11148, 0x1114F).addRange(0x11177, 0x1117F).addRange(0x111F5, 0x111FF).addRange(0x11242, 0x1127F).addRange(0x112AA, 0x112AF).addRange(0x112EB, 0x112EF).addRange(0x112FA, 0x112FF).addRange(0x1130D, 0x1130E).addRange(0x11311, 0x11312).addRange(0x11345, 0x11346).addRange(0x11349, 0x1134A).addRange(0x1134E, 0x1134F).addRange(0x11351, 0x11356).addRange(0x11358, 0x1135C).addRange(0x11364, 0x11365).addRange(0x1136D, 0x1136F).addRange(0x11375, 0x1137F).addRange(0x1138C, 0x1138D).addRange(0x113C3, 0x113C4).addRange(0x113D9, 0x113E0).addRange(0x113E3, 0x113FF).addRange(0x11462, 0x1147F).addRange(0x114C8, 0x114CF).addRange(0x114DA, 0x1157F).addRange(0x115B6, 0x115B7).addRange(0x115DE, 0x115FF).addRange(0x11645, 0x1164F).addRange(0x1165A, 0x1165F).addRange(0x1166D, 0x1167F); +set.addRange(0x116BA, 0x116BF).addRange(0x116CA, 0x116CF).addRange(0x116E4, 0x116FF).addRange(0x1171B, 0x1171C).addRange(0x1172C, 0x1172F).addRange(0x11747, 0x117FF).addRange(0x1183C, 0x1189F).addRange(0x118F3, 0x118FE).addRange(0x11907, 0x11908).addRange(0x1190A, 0x1190B).addRange(0x11939, 0x1193A).addRange(0x11947, 0x1194F).addRange(0x1195A, 0x1199F).addRange(0x119A8, 0x119A9).addRange(0x119D8, 0x119D9).addRange(0x119E5, 0x119FF).addRange(0x11A48, 0x11A4F).addRange(0x11AA3, 0x11AAF).addRange(0x11AF9, 0x11AFF).addRange(0x11B0A, 0x11B5F).addRange(0x11B68, 0x11BBF).addRange(0x11BE2, 0x11BEF).addRange(0x11BFA, 0x11BFF).addRange(0x11C46, 0x11C4F).addRange(0x11C6D, 0x11C6F).addRange(0x11C90, 0x11C91).addRange(0x11CB7, 0x11CFF).addRange(0x11D37, 0x11D39).addRange(0x11D48, 0x11D4F).addRange(0x11D5A, 0x11D5F).addRange(0x11D99, 0x11D9F).addRange(0x11DAA, 0x11DAF).addRange(0x11DDC, 0x11DDF).addRange(0x11DEA, 0x11EDF).addRange(0x11EF9, 0x11EFF).addRange(0x11F3B, 0x11F3D).addRange(0x11F5B, 0x11FAF).addRange(0x11FB1, 0x11FBF).addRange(0x11FF2, 0x11FFE).addRange(0x1239A, 0x123FF).addRange(0x12475, 0x1247F).addRange(0x12544, 0x12F8F).addRange(0x12FF3, 0x12FFF).addRange(0x13456, 0x1345F).addRange(0x143FB, 0x143FF).addRange(0x14647, 0x160FF).addRange(0x1613A, 0x167FF).addRange(0x16A39, 0x16A3F).addRange(0x16A6A, 0x16A6D).addRange(0x16ACA, 0x16ACF).addRange(0x16AEE, 0x16AEF); +set.addRange(0x16AF6, 0x16AFF).addRange(0x16B46, 0x16B4F).addRange(0x16B78, 0x16B7C).addRange(0x16B90, 0x16D3F).addRange(0x16D7A, 0x16E3F).addRange(0x16E9B, 0x16E9F).addRange(0x16EB9, 0x16EBA).addRange(0x16ED4, 0x16EFF).addRange(0x16F4B, 0x16F4E).addRange(0x16F88, 0x16F8E).addRange(0x16FA0, 0x16FDF).addRange(0x16FE5, 0x16FEF).addRange(0x16FF7, 0x16FFF).addRange(0x18CD6, 0x18CFE).addRange(0x18D1F, 0x18D7F).addRange(0x18DF3, 0x1AFEF).addRange(0x1B123, 0x1B131).addRange(0x1B133, 0x1B14F).addRange(0x1B153, 0x1B154).addRange(0x1B156, 0x1B163).addRange(0x1B168, 0x1B16F).addRange(0x1B2FC, 0x1BBFF).addRange(0x1BC6B, 0x1BC6F).addRange(0x1BC7D, 0x1BC7F).addRange(0x1BC89, 0x1BC8F).addRange(0x1BC9A, 0x1BC9B).addRange(0x1BCA4, 0x1CBFF).addRange(0x1CCFD, 0x1CCFF).addRange(0x1CEB4, 0x1CEB9).addRange(0x1CED1, 0x1CEDF).addRange(0x1CEF1, 0x1CEFF).addRange(0x1CF2E, 0x1CF2F).addRange(0x1CF47, 0x1CF4F).addRange(0x1CFC4, 0x1CFFF).addRange(0x1D0F6, 0x1D0FF).addRange(0x1D127, 0x1D128).addRange(0x1D1EB, 0x1D1FF).addRange(0x1D246, 0x1D2BF).addRange(0x1D2D4, 0x1D2DF).addRange(0x1D2F4, 0x1D2FF).addRange(0x1D357, 0x1D35F).addRange(0x1D379, 0x1D3FF).addRange(0x1D4A0, 0x1D4A1).addRange(0x1D4A3, 0x1D4A4).addRange(0x1D4A7, 0x1D4A8).addRange(0x1D50B, 0x1D50C).addRange(0x1D547, 0x1D549).addRange(0x1D6A6, 0x1D6A7).addRange(0x1D7CC, 0x1D7CD).addRange(0x1DA8C, 0x1DA9A).addRange(0x1DAB0, 0x1DEFF); +set.addRange(0x1DF1F, 0x1DF24).addRange(0x1DF2B, 0x1DFFF).addRange(0x1E019, 0x1E01A).addRange(0x1E02B, 0x1E02F).addRange(0x1E06E, 0x1E08E).addRange(0x1E090, 0x1E0FF).addRange(0x1E12D, 0x1E12F).addRange(0x1E13E, 0x1E13F).addRange(0x1E14A, 0x1E14D).addRange(0x1E150, 0x1E28F).addRange(0x1E2AF, 0x1E2BF).addRange(0x1E2FA, 0x1E2FE).addRange(0x1E300, 0x1E4CF).addRange(0x1E4FA, 0x1E5CF).addRange(0x1E5FB, 0x1E5FE).addRange(0x1E600, 0x1E6BF).addRange(0x1E6F6, 0x1E6FD).addRange(0x1E700, 0x1E7DF).addRange(0x1E8C5, 0x1E8C6).addRange(0x1E8D7, 0x1E8FF).addRange(0x1E94C, 0x1E94F).addRange(0x1E95A, 0x1E95D).addRange(0x1E960, 0x1EC70).addRange(0x1ECB5, 0x1ED00).addRange(0x1ED3E, 0x1EDFF).addRange(0x1EE25, 0x1EE26).addRange(0x1EE3C, 0x1EE41).addRange(0x1EE43, 0x1EE46).addRange(0x1EE55, 0x1EE56).addRange(0x1EE65, 0x1EE66).addRange(0x1EE9C, 0x1EEA0).addRange(0x1EEBC, 0x1EEEF).addRange(0x1EEF2, 0x1EFFF).addRange(0x1F02C, 0x1F02F).addRange(0x1F094, 0x1F09F).addRange(0x1F0AF, 0x1F0B0).addRange(0x1F0F6, 0x1F0FF).addRange(0x1F1AE, 0x1F1E5).addRange(0x1F203, 0x1F20F).addRange(0x1F23C, 0x1F23F).addRange(0x1F249, 0x1F24F).addRange(0x1F252, 0x1F25F).addRange(0x1F266, 0x1F2FF).addRange(0x1F6D9, 0x1F6DB).addRange(0x1F6ED, 0x1F6EF).addRange(0x1F6FD, 0x1F6FF).addRange(0x1F7DA, 0x1F7DF).addRange(0x1F7EC, 0x1F7EF).addRange(0x1F7F1, 0x1F7FF).addRange(0x1F80C, 0x1F80F).addRange(0x1F848, 0x1F84F); +set.addRange(0x1F85A, 0x1F85F).addRange(0x1F888, 0x1F88F).addRange(0x1F8AE, 0x1F8AF).addRange(0x1F8BC, 0x1F8BF).addRange(0x1F8C2, 0x1F8CF).addRange(0x1F8D9, 0x1F8FF).addRange(0x1FA58, 0x1FA5F).addRange(0x1FA6E, 0x1FA6F).addRange(0x1FA7D, 0x1FA7F).addRange(0x1FA8B, 0x1FA8D).addRange(0x1FAC9, 0x1FACC).addRange(0x1FADD, 0x1FADE).addRange(0x1FAEB, 0x1FAEE).addRange(0x1FAF9, 0x1FAFF).addRange(0x1FBFB, 0x1FFFF).addRange(0x2A6E0, 0x2A6FF).addRange(0x2B81E, 0x2B81F).addRange(0x2CEAE, 0x2CEAF).addRange(0x2EBE1, 0x2EBEF).addRange(0x2EE5E, 0x2F7FF).addRange(0x2FA1E, 0x2FFFF).addRange(0x3134B, 0x3134F).addRange(0x3347A, 0xE0000).addRange(0xE0002, 0xE001F).addRange(0xE0080, 0xE00FF).addRange(0xE01F0, 0xEFFFF).addRange(0xFFFFE, 0xFFFFF).addRange(0x10FFFE, 0x10FFFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Uppercase_Letter.js b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Uppercase_Letter.js new file mode 100644 index 0000000000000000000000000000000000000000..6615244031bb08fc6062ed72ef140ac5eb657569 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/General_Category/Uppercase_Letter.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14A, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x17B, 0x17D, 0x184, 0x1A2, 0x1A4, 0x1A9, 0x1AC, 0x1B5, 0x1BC, 0x1C4, 0x1C7, 0x1CA, 0x1CD, 0x1CF, 0x1D1, 0x1D3, 0x1D5, 0x1D7, 0x1D9, 0x1DB, 0x1DE, 0x1E0, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x1EA, 0x1EC, 0x1EE, 0x1F1, 0x1F4, 0x1FA, 0x1FC, 0x1FE, 0x200, 0x202, 0x204, 0x206, 0x208, 0x20A, 0x20C, 0x20E, 0x210, 0x212, 0x214, 0x216, 0x218, 0x21A, 0x21C, 0x21E, 0x220, 0x222, 0x224, 0x226, 0x228, 0x22A, 0x22C, 0x22E, 0x230, 0x232, 0x241, 0x248, 0x24A, 0x24C, 0x24E, 0x370, 0x372, 0x376, 0x37F, 0x386, 0x38C, 0x3CF, 0x3D8, 0x3DA, 0x3DC, 0x3DE, 0x3E0, 0x3E2, 0x3E4, 0x3E6, 0x3E8, 0x3EA, 0x3EC, 0x3EE, 0x3F4, 0x3F7, 0x460, 0x462, 0x464, 0x466, 0x468, 0x46A, 0x46C, 0x46E, 0x470, 0x472, 0x474, 0x476, 0x478, 0x47A, 0x47C, 0x47E, 0x480, 0x48A, 0x48C, 0x48E, 0x490, 0x492, 0x494, 0x496, 0x498, 0x49A, 0x49C, 0x49E, 0x4A0, 0x4A2, 0x4A4, 0x4A6, 0x4A8, 0x4AA, 0x4AC, 0x4AE, 0x4B0, 0x4B2, 0x4B4, 0x4B6, 0x4B8, 0x4BA, 0x4BC, 0x4BE, 0x4C3, 0x4C5, 0x4C7, 0x4C9, 0x4CB, 0x4CD, 0x4D0, 0x4D2, 0x4D4, 0x4D6, 0x4D8, 0x4DA, 0x4DC, 0x4DE, 0x4E0, 0x4E2, 0x4E4, 0x4E6, 0x4E8, 0x4EA, 0x4EC, 0x4EE, 0x4F0, 0x4F2, 0x4F4, 0x4F6, 0x4F8, 0x4FA, 0x4FC, 0x4FE, 0x500, 0x502, 0x504, 0x506, 0x508, 0x50A, 0x50C, 0x50E, 0x510, 0x512, 0x514, 0x516, 0x518, 0x51A, 0x51C, 0x51E, 0x520, 0x522, 0x524, 0x526, 0x528, 0x52A, 0x52C, 0x52E, 0x10C7, 0x10CD, 0x1C89, 0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12, 0x1E14, 0x1E16, 0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26, 0x1E28, 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, 0x1E3A, 0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C, 0x1E4E, 0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62, 0x1E64, 0x1E66, 0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76, 0x1E78, 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, 0x1E8A, 0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94, 0x1E9E, 0x1EA0, 0x1EA2, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4, 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4, 0x1EF6, 0x1EF8, 0x1EFA, 0x1EFC, 0x1EFE, 0x1F59, 0x1F5B, 0x1F5D, 0x1F5F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2145, 0x2183, 0x2C60, 0x2C67, 0x2C69, 0x2C6B, 0x2C72, 0x2C75, 0x2C82, 0x2C84, 0x2C86, 0x2C88, 0x2C8A, 0x2C8C, 0x2C8E, 0x2C90, 0x2C92, 0x2C94, 0x2C96, 0x2C98, 0x2C9A, 0x2C9C, 0x2C9E, 0x2CA0, 0x2CA2, 0x2CA4, 0x2CA6, 0x2CA8, 0x2CAA, 0x2CAC, 0x2CAE, 0x2CB0, 0x2CB2, 0x2CB4, 0x2CB6, 0x2CB8, 0x2CBA, 0x2CBC, 0x2CBE, 0x2CC0, 0x2CC2, 0x2CC4, 0x2CC6, 0x2CC8, 0x2CCA, 0x2CCC, 0x2CCE, 0x2CD0, 0x2CD2, 0x2CD4, 0x2CD6, 0x2CD8, 0x2CDA, 0x2CDC, 0x2CDE, 0x2CE0, 0x2CE2, 0x2CEB, 0x2CED, 0x2CF2, 0xA640, 0xA642, 0xA644, 0xA646, 0xA648, 0xA64A, 0xA64C, 0xA64E, 0xA650, 0xA652, 0xA654, 0xA656, 0xA658, 0xA65A, 0xA65C, 0xA65E, 0xA660, 0xA662, 0xA664, 0xA666, 0xA668, 0xA66A, 0xA66C, 0xA680, 0xA682, 0xA684, 0xA686, 0xA688, 0xA68A, 0xA68C, 0xA68E, 0xA690, 0xA692, 0xA694, 0xA696, 0xA698, 0xA69A, 0xA722, 0xA724, 0xA726, 0xA728, 0xA72A, 0xA72C, 0xA72E, 0xA732, 0xA734, 0xA736, 0xA738, 0xA73A, 0xA73C, 0xA73E, 0xA740, 0xA742, 0xA744, 0xA746, 0xA748, 0xA74A, 0xA74C, 0xA74E, 0xA750, 0xA752, 0xA754, 0xA756, 0xA758, 0xA75A, 0xA75C, 0xA75E, 0xA760, 0xA762, 0xA764, 0xA766, 0xA768, 0xA76A, 0xA76C, 0xA76E, 0xA779, 0xA77B, 0xA780, 0xA782, 0xA784, 0xA786, 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798, 0xA79A, 0xA79C, 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7B6, 0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C9, 0xA7CE, 0xA7D0, 0xA7D2, 0xA7D4, 0xA7D6, 0xA7D8, 0xA7DA, 0xA7DC, 0xA7F5, 0x1D49C, 0x1D4A2, 0x1D546, 0x1D7CA); +set.addRange(0x41, 0x5A).addRange(0xC0, 0xD6).addRange(0xD8, 0xDE).addRange(0x178, 0x179).addRange(0x181, 0x182).addRange(0x186, 0x187).addRange(0x189, 0x18B).addRange(0x18E, 0x191).addRange(0x193, 0x194).addRange(0x196, 0x198).addRange(0x19C, 0x19D).addRange(0x19F, 0x1A0).addRange(0x1A6, 0x1A7).addRange(0x1AE, 0x1AF).addRange(0x1B1, 0x1B3).addRange(0x1B7, 0x1B8).addRange(0x1F6, 0x1F8).addRange(0x23A, 0x23B).addRange(0x23D, 0x23E).addRange(0x243, 0x246).addRange(0x388, 0x38A).addRange(0x38E, 0x38F).addRange(0x391, 0x3A1).addRange(0x3A3, 0x3AB).addRange(0x3D2, 0x3D4).addRange(0x3F9, 0x3FA).addRange(0x3FD, 0x42F).addRange(0x4C0, 0x4C1).addRange(0x531, 0x556).addRange(0x10A0, 0x10C5).addRange(0x13A0, 0x13F5).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1F08, 0x1F0F).addRange(0x1F18, 0x1F1D).addRange(0x1F28, 0x1F2F).addRange(0x1F38, 0x1F3F).addRange(0x1F48, 0x1F4D).addRange(0x1F68, 0x1F6F).addRange(0x1FB8, 0x1FBB).addRange(0x1FC8, 0x1FCB).addRange(0x1FD8, 0x1FDB).addRange(0x1FE8, 0x1FEC).addRange(0x1FF8, 0x1FFB).addRange(0x210B, 0x210D).addRange(0x2110, 0x2112).addRange(0x2119, 0x211D).addRange(0x212A, 0x212D).addRange(0x2130, 0x2133).addRange(0x213E, 0x213F).addRange(0x2C00, 0x2C2F); +set.addRange(0x2C62, 0x2C64).addRange(0x2C6D, 0x2C70).addRange(0x2C7E, 0x2C80).addRange(0xA77D, 0xA77E).addRange(0xA7AA, 0xA7AE).addRange(0xA7B0, 0xA7B4).addRange(0xA7C4, 0xA7C7).addRange(0xA7CB, 0xA7CC).addRange(0xFF21, 0xFF3A).addRange(0x10400, 0x10427).addRange(0x104B0, 0x104D3).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10C80, 0x10CB2).addRange(0x10D50, 0x10D65).addRange(0x118A0, 0x118BF).addRange(0x16E40, 0x16E5F).addRange(0x16EA0, 0x16EB8).addRange(0x1D400, 0x1D419).addRange(0x1D434, 0x1D44D).addRange(0x1D468, 0x1D481).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B5).addRange(0x1D4D0, 0x1D4E9).addRange(0x1D504, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D538, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D56C, 0x1D585).addRange(0x1D5A0, 0x1D5B9).addRange(0x1D5D4, 0x1D5ED).addRange(0x1D608, 0x1D621).addRange(0x1D63C, 0x1D655).addRange(0x1D670, 0x1D689).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6E2, 0x1D6FA).addRange(0x1D71C, 0x1D734).addRange(0x1D756, 0x1D76E).addRange(0x1D790, 0x1D7A8).addRange(0x1E900, 0x1E921); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/LICENSE-MIT.txt b/tools/ui/node_modules/regenerate-unicode-properties/LICENSE-MIT.txt new file mode 100644 index 0000000000000000000000000000000000000000..a41e0a7ef970ecdd83d82cd99bda97b22077bc62 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/LICENSE-MIT.txt @@ -0,0 +1,20 @@ +Copyright Mathias Bynens + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/Basic_Emoji.js b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/Basic_Emoji.js new file mode 100644 index 0000000000000000000000000000000000000000..1d1961c0a3a25e85ffa31ac922643bc6430353bc --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/Basic_Emoji.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0x23F0, 0x23F3, 0x267F, 0x2693, 0x26A1, 0x26CE, 0x26D4, 0x26EA, 0x26F5, 0x26FA, 0x26FD, 0x2705, 0x2728, 0x274C, 0x274E, 0x2757, 0x27B0, 0x27BF, 0x2B50, 0x2B55, 0x1F004, 0x1F0CF, 0x1F18E, 0x1F201, 0x1F21A, 0x1F22F, 0x1F3F4, 0x1F440, 0x1F57A, 0x1F5A4, 0x1F6CC, 0x1F7F0, 0x1FAC8); +set.addRange(0x231A, 0x231B).addRange(0x23E9, 0x23EC).addRange(0x25FD, 0x25FE).addRange(0x2614, 0x2615).addRange(0x2648, 0x2653).addRange(0x26AA, 0x26AB).addRange(0x26BD, 0x26BE).addRange(0x26C4, 0x26C5).addRange(0x26F2, 0x26F3).addRange(0x270A, 0x270B).addRange(0x2753, 0x2755).addRange(0x2795, 0x2797).addRange(0x2B1B, 0x2B1C).addRange(0x1F191, 0x1F19A).addRange(0x1F232, 0x1F236).addRange(0x1F238, 0x1F23A).addRange(0x1F250, 0x1F251).addRange(0x1F300, 0x1F320).addRange(0x1F32D, 0x1F335).addRange(0x1F337, 0x1F37C).addRange(0x1F37E, 0x1F393).addRange(0x1F3A0, 0x1F3CA).addRange(0x1F3CF, 0x1F3D3).addRange(0x1F3E0, 0x1F3F0).addRange(0x1F3F8, 0x1F43E).addRange(0x1F442, 0x1F4FC).addRange(0x1F4FF, 0x1F53D).addRange(0x1F54B, 0x1F54E).addRange(0x1F550, 0x1F567).addRange(0x1F595, 0x1F596).addRange(0x1F5FB, 0x1F64F).addRange(0x1F680, 0x1F6C5).addRange(0x1F6D0, 0x1F6D2).addRange(0x1F6D5, 0x1F6D8).addRange(0x1F6DC, 0x1F6DF).addRange(0x1F6EB, 0x1F6EC).addRange(0x1F6F4, 0x1F6FC).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F90C, 0x1F93A).addRange(0x1F93C, 0x1F945).addRange(0x1F947, 0x1F9FF).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA8A).addRange(0x1FA8E, 0x1FAC6).addRange(0x1FACD, 0x1FADC).addRange(0x1FADF, 0x1FAEA).addRange(0x1FAEF, 0x1FAF8); +exports.characters = set; +exports.strings = ['\xA9\uFE0F','\xAE\uFE0F','\u203C\uFE0F','\u2049\uFE0F','\u2122\uFE0F','\u2139\uFE0F','\u2194\uFE0F','\u2195\uFE0F','\u2196\uFE0F','\u2197\uFE0F','\u2198\uFE0F','\u2199\uFE0F','\u21A9\uFE0F','\u21AA\uFE0F','\u2328\uFE0F','\u23CF\uFE0F','\u23ED\uFE0F','\u23EE\uFE0F','\u23EF\uFE0F','\u23F1\uFE0F','\u23F2\uFE0F','\u23F8\uFE0F','\u23F9\uFE0F','\u23FA\uFE0F','\u24C2\uFE0F','\u25AA\uFE0F','\u25AB\uFE0F','\u25B6\uFE0F','\u25C0\uFE0F','\u25FB\uFE0F','\u25FC\uFE0F','\u2600\uFE0F','\u2601\uFE0F','\u2602\uFE0F','\u2603\uFE0F','\u2604\uFE0F','\u260E\uFE0F','\u2611\uFE0F','\u2618\uFE0F','\u261D\uFE0F','\u2620\uFE0F','\u2622\uFE0F','\u2623\uFE0F','\u2626\uFE0F','\u262A\uFE0F','\u262E\uFE0F','\u262F\uFE0F','\u2638\uFE0F','\u2639\uFE0F','\u263A\uFE0F','\u2640\uFE0F','\u2642\uFE0F','\u265F\uFE0F','\u2660\uFE0F','\u2663\uFE0F','\u2665\uFE0F','\u2666\uFE0F','\u2668\uFE0F','\u267B\uFE0F','\u267E\uFE0F','\u2692\uFE0F','\u2694\uFE0F','\u2695\uFE0F','\u2696\uFE0F','\u2697\uFE0F','\u2699\uFE0F','\u269B\uFE0F','\u269C\uFE0F','\u26A0\uFE0F','\u26A7\uFE0F','\u26B0\uFE0F','\u26B1\uFE0F','\u26C8\uFE0F','\u26CF\uFE0F','\u26D1\uFE0F','\u26D3\uFE0F','\u26E9\uFE0F','\u26F0\uFE0F','\u26F1\uFE0F','\u26F4\uFE0F','\u26F7\uFE0F','\u26F8\uFE0F','\u26F9\uFE0F','\u2702\uFE0F','\u2708\uFE0F','\u2709\uFE0F','\u270C\uFE0F','\u270D\uFE0F','\u270F\uFE0F','\u2712\uFE0F','\u2714\uFE0F','\u2716\uFE0F','\u271D\uFE0F','\u2721\uFE0F','\u2733\uFE0F','\u2734\uFE0F','\u2744\uFE0F','\u2747\uFE0F','\u2763\uFE0F','\u2764\uFE0F','\u27A1\uFE0F','\u2934\uFE0F','\u2935\uFE0F','\u2B05\uFE0F','\u2B06\uFE0F','\u2B07\uFE0F','\u3030\uFE0F','\u303D\uFE0F','\u3297\uFE0F','\u3299\uFE0F','\u{1F170}\uFE0F','\u{1F171}\uFE0F','\u{1F17E}\uFE0F','\u{1F17F}\uFE0F','\u{1F202}\uFE0F','\u{1F237}\uFE0F','\u{1F321}\uFE0F','\u{1F324}\uFE0F','\u{1F325}\uFE0F','\u{1F326}\uFE0F','\u{1F327}\uFE0F','\u{1F328}\uFE0F','\u{1F329}\uFE0F','\u{1F32A}\uFE0F','\u{1F32B}\uFE0F','\u{1F32C}\uFE0F','\u{1F336}\uFE0F','\u{1F37D}\uFE0F','\u{1F396}\uFE0F','\u{1F397}\uFE0F','\u{1F399}\uFE0F','\u{1F39A}\uFE0F','\u{1F39B}\uFE0F','\u{1F39E}\uFE0F','\u{1F39F}\uFE0F','\u{1F3CB}\uFE0F','\u{1F3CC}\uFE0F','\u{1F3CD}\uFE0F','\u{1F3CE}\uFE0F','\u{1F3D4}\uFE0F','\u{1F3D5}\uFE0F','\u{1F3D6}\uFE0F','\u{1F3D7}\uFE0F','\u{1F3D8}\uFE0F','\u{1F3D9}\uFE0F','\u{1F3DA}\uFE0F','\u{1F3DB}\uFE0F','\u{1F3DC}\uFE0F','\u{1F3DD}\uFE0F','\u{1F3DE}\uFE0F','\u{1F3DF}\uFE0F','\u{1F3F3}\uFE0F','\u{1F3F5}\uFE0F','\u{1F3F7}\uFE0F','\u{1F43F}\uFE0F','\u{1F441}\uFE0F','\u{1F4FD}\uFE0F','\u{1F549}\uFE0F','\u{1F54A}\uFE0F','\u{1F56F}\uFE0F','\u{1F570}\uFE0F','\u{1F573}\uFE0F','\u{1F574}\uFE0F','\u{1F575}\uFE0F','\u{1F576}\uFE0F','\u{1F577}\uFE0F','\u{1F578}\uFE0F','\u{1F579}\uFE0F','\u{1F587}\uFE0F','\u{1F58A}\uFE0F','\u{1F58B}\uFE0F','\u{1F58C}\uFE0F','\u{1F58D}\uFE0F','\u{1F590}\uFE0F','\u{1F5A5}\uFE0F','\u{1F5A8}\uFE0F','\u{1F5B1}\uFE0F','\u{1F5B2}\uFE0F','\u{1F5BC}\uFE0F','\u{1F5C2}\uFE0F','\u{1F5C3}\uFE0F','\u{1F5C4}\uFE0F','\u{1F5D1}\uFE0F','\u{1F5D2}\uFE0F','\u{1F5D3}\uFE0F','\u{1F5DC}\uFE0F','\u{1F5DD}\uFE0F','\u{1F5DE}\uFE0F','\u{1F5E1}\uFE0F','\u{1F5E3}\uFE0F','\u{1F5E8}\uFE0F','\u{1F5EF}\uFE0F','\u{1F5F3}\uFE0F','\u{1F5FA}\uFE0F','\u{1F6CB}\uFE0F','\u{1F6CD}\uFE0F','\u{1F6CE}\uFE0F','\u{1F6CF}\uFE0F','\u{1F6E0}\uFE0F','\u{1F6E1}\uFE0F','\u{1F6E2}\uFE0F','\u{1F6E3}\uFE0F','\u{1F6E4}\uFE0F','\u{1F6E5}\uFE0F','\u{1F6E9}\uFE0F','\u{1F6F0}\uFE0F','\u{1F6F3}\uFE0F']; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/Emoji_Keycap_Sequence.js b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/Emoji_Keycap_Sequence.js new file mode 100644 index 0000000000000000000000000000000000000000..dfe7185305baaafbf242e5215c62adf30df2e313 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/Emoji_Keycap_Sequence.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(); + +exports.characters = set; +exports.strings = ['#\uFE0F\u20E3','*\uFE0F\u20E3','0\uFE0F\u20E3','1\uFE0F\u20E3','2\uFE0F\u20E3','3\uFE0F\u20E3','4\uFE0F\u20E3','5\uFE0F\u20E3','6\uFE0F\u20E3','7\uFE0F\u20E3','8\uFE0F\u20E3','9\uFE0F\u20E3']; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji.js b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji.js new file mode 100644 index 0000000000000000000000000000000000000000..f5006e7eba3698b81845aa9fe5e2ba9c3156eb23 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(0x23F0, 0x23F3, 0x267F, 0x2693, 0x26A1, 0x26CE, 0x26D4, 0x26EA, 0x26F5, 0x26FA, 0x26FD, 0x2705, 0x2728, 0x274C, 0x274E, 0x2757, 0x27B0, 0x27BF, 0x2B50, 0x2B55, 0x1F004, 0x1F0CF, 0x1F18E, 0x1F201, 0x1F21A, 0x1F22F, 0x1F3F4, 0x1F440, 0x1F57A, 0x1F5A4, 0x1F6CC, 0x1F7F0, 0x1FAC8); +set.addRange(0x231A, 0x231B).addRange(0x23E9, 0x23EC).addRange(0x25FD, 0x25FE).addRange(0x2614, 0x2615).addRange(0x2648, 0x2653).addRange(0x26AA, 0x26AB).addRange(0x26BD, 0x26BE).addRange(0x26C4, 0x26C5).addRange(0x26F2, 0x26F3).addRange(0x270A, 0x270B).addRange(0x2753, 0x2755).addRange(0x2795, 0x2797).addRange(0x2B1B, 0x2B1C).addRange(0x1F191, 0x1F19A).addRange(0x1F232, 0x1F236).addRange(0x1F238, 0x1F23A).addRange(0x1F250, 0x1F251).addRange(0x1F300, 0x1F320).addRange(0x1F32D, 0x1F335).addRange(0x1F337, 0x1F37C).addRange(0x1F37E, 0x1F393).addRange(0x1F3A0, 0x1F3CA).addRange(0x1F3CF, 0x1F3D3).addRange(0x1F3E0, 0x1F3F0).addRange(0x1F3F8, 0x1F43E).addRange(0x1F442, 0x1F4FC).addRange(0x1F4FF, 0x1F53D).addRange(0x1F54B, 0x1F54E).addRange(0x1F550, 0x1F567).addRange(0x1F595, 0x1F596).addRange(0x1F5FB, 0x1F64F).addRange(0x1F680, 0x1F6C5).addRange(0x1F6D0, 0x1F6D2).addRange(0x1F6D5, 0x1F6D8).addRange(0x1F6DC, 0x1F6DF).addRange(0x1F6EB, 0x1F6EC).addRange(0x1F6F4, 0x1F6FC).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F90C, 0x1F93A).addRange(0x1F93C, 0x1F945).addRange(0x1F947, 0x1F9FF).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA8A).addRange(0x1FA8E, 0x1FAC6).addRange(0x1FACD, 0x1FADC).addRange(0x1FADF, 0x1FAEA).addRange(0x1FAEF, 0x1FAF8); +exports.characters = set; +exports.strings = ['#\uFE0F\u20E3','*\uFE0F\u20E3','0\uFE0F\u20E3','1\uFE0F\u20E3','2\uFE0F\u20E3','3\uFE0F\u20E3','4\uFE0F\u20E3','5\uFE0F\u20E3','6\uFE0F\u20E3','7\uFE0F\u20E3','8\uFE0F\u20E3','9\uFE0F\u20E3','\xA9\uFE0F','\xAE\uFE0F','\u203C\uFE0F','\u2049\uFE0F','\u2122\uFE0F','\u2139\uFE0F','\u2194\uFE0F','\u2195\uFE0F','\u2196\uFE0F','\u2197\uFE0F','\u2198\uFE0F','\u2199\uFE0F','\u21A9\uFE0F','\u21AA\uFE0F','\u2328\uFE0F','\u23CF\uFE0F','\u23ED\uFE0F','\u23EE\uFE0F','\u23EF\uFE0F','\u23F1\uFE0F','\u23F2\uFE0F','\u23F8\uFE0F','\u23F9\uFE0F','\u23FA\uFE0F','\u24C2\uFE0F','\u25AA\uFE0F','\u25AB\uFE0F','\u25B6\uFE0F','\u25C0\uFE0F','\u25FB\uFE0F','\u25FC\uFE0F','\u2600\uFE0F','\u2601\uFE0F','\u2602\uFE0F','\u2603\uFE0F','\u2604\uFE0F','\u260E\uFE0F','\u2611\uFE0F','\u2618\uFE0F','\u261D\u{1F3FB}','\u261D\u{1F3FC}','\u261D\u{1F3FD}','\u261D\u{1F3FE}','\u261D\u{1F3FF}','\u261D\uFE0F','\u2620\uFE0F','\u2622\uFE0F','\u2623\uFE0F','\u2626\uFE0F','\u262A\uFE0F','\u262E\uFE0F','\u262F\uFE0F','\u2638\uFE0F','\u2639\uFE0F','\u263A\uFE0F','\u2640\uFE0F','\u2642\uFE0F','\u265F\uFE0F','\u2660\uFE0F','\u2663\uFE0F','\u2665\uFE0F','\u2666\uFE0F','\u2668\uFE0F','\u267B\uFE0F','\u267E\uFE0F','\u2692\uFE0F','\u2694\uFE0F','\u2695\uFE0F','\u2696\uFE0F','\u2697\uFE0F','\u2699\uFE0F','\u269B\uFE0F','\u269C\uFE0F','\u26A0\uFE0F','\u26A7\uFE0F','\u26B0\uFE0F','\u26B1\uFE0F','\u26C8\uFE0F','\u26CF\uFE0F','\u26D1\uFE0F','\u26D3\uFE0F','\u26D3\uFE0F\u200D\u{1F4A5}','\u26E9\uFE0F','\u26F0\uFE0F','\u26F1\uFE0F','\u26F4\uFE0F','\u26F7\uFE0F','\u26F8\uFE0F','\u26F9\u{1F3FB}','\u26F9\u{1F3FB}\u200D\u2640\uFE0F','\u26F9\u{1F3FB}\u200D\u2642\uFE0F','\u26F9\u{1F3FC}','\u26F9\u{1F3FC}\u200D\u2640\uFE0F','\u26F9\u{1F3FC}\u200D\u2642\uFE0F','\u26F9\u{1F3FD}','\u26F9\u{1F3FD}\u200D\u2640\uFE0F','\u26F9\u{1F3FD}\u200D\u2642\uFE0F','\u26F9\u{1F3FE}','\u26F9\u{1F3FE}\u200D\u2640\uFE0F','\u26F9\u{1F3FE}\u200D\u2642\uFE0F','\u26F9\u{1F3FF}','\u26F9\u{1F3FF}\u200D\u2640\uFE0F','\u26F9\u{1F3FF}\u200D\u2642\uFE0F','\u26F9\uFE0F','\u26F9\uFE0F\u200D\u2640\uFE0F','\u26F9\uFE0F\u200D\u2642\uFE0F','\u2702\uFE0F','\u2708\uFE0F','\u2709\uFE0F','\u270A\u{1F3FB}','\u270A\u{1F3FC}','\u270A\u{1F3FD}','\u270A\u{1F3FE}','\u270A\u{1F3FF}','\u270B\u{1F3FB}','\u270B\u{1F3FC}','\u270B\u{1F3FD}','\u270B\u{1F3FE}','\u270B\u{1F3FF}','\u270C\u{1F3FB}','\u270C\u{1F3FC}','\u270C\u{1F3FD}','\u270C\u{1F3FE}','\u270C\u{1F3FF}','\u270C\uFE0F','\u270D\u{1F3FB}','\u270D\u{1F3FC}','\u270D\u{1F3FD}','\u270D\u{1F3FE}','\u270D\u{1F3FF}','\u270D\uFE0F','\u270F\uFE0F','\u2712\uFE0F','\u2714\uFE0F','\u2716\uFE0F','\u271D\uFE0F','\u2721\uFE0F','\u2733\uFE0F','\u2734\uFE0F','\u2744\uFE0F','\u2747\uFE0F','\u2763\uFE0F','\u2764\uFE0F','\u2764\uFE0F\u200D\u{1F525}','\u2764\uFE0F\u200D\u{1FA79}','\u27A1\uFE0F','\u2934\uFE0F','\u2935\uFE0F','\u2B05\uFE0F','\u2B06\uFE0F','\u2B07\uFE0F','\u3030\uFE0F','\u303D\uFE0F','\u3297\uFE0F','\u3299\uFE0F','\u{1F170}\uFE0F','\u{1F171}\uFE0F','\u{1F17E}\uFE0F','\u{1F17F}\uFE0F','\u{1F1E6}\u{1F1E8}','\u{1F1E6}\u{1F1E9}','\u{1F1E6}\u{1F1EA}','\u{1F1E6}\u{1F1EB}','\u{1F1E6}\u{1F1EC}','\u{1F1E6}\u{1F1EE}','\u{1F1E6}\u{1F1F1}','\u{1F1E6}\u{1F1F2}','\u{1F1E6}\u{1F1F4}','\u{1F1E6}\u{1F1F6}','\u{1F1E6}\u{1F1F7}','\u{1F1E6}\u{1F1F8}','\u{1F1E6}\u{1F1F9}','\u{1F1E6}\u{1F1FA}','\u{1F1E6}\u{1F1FC}','\u{1F1E6}\u{1F1FD}','\u{1F1E6}\u{1F1FF}','\u{1F1E7}\u{1F1E6}','\u{1F1E7}\u{1F1E7}','\u{1F1E7}\u{1F1E9}','\u{1F1E7}\u{1F1EA}','\u{1F1E7}\u{1F1EB}','\u{1F1E7}\u{1F1EC}','\u{1F1E7}\u{1F1ED}','\u{1F1E7}\u{1F1EE}','\u{1F1E7}\u{1F1EF}','\u{1F1E7}\u{1F1F1}','\u{1F1E7}\u{1F1F2}','\u{1F1E7}\u{1F1F3}','\u{1F1E7}\u{1F1F4}','\u{1F1E7}\u{1F1F6}','\u{1F1E7}\u{1F1F7}','\u{1F1E7}\u{1F1F8}','\u{1F1E7}\u{1F1F9}','\u{1F1E7}\u{1F1FB}','\u{1F1E7}\u{1F1FC}','\u{1F1E7}\u{1F1FE}','\u{1F1E7}\u{1F1FF}','\u{1F1E8}\u{1F1E6}','\u{1F1E8}\u{1F1E8}','\u{1F1E8}\u{1F1E9}','\u{1F1E8}\u{1F1EB}','\u{1F1E8}\u{1F1EC}','\u{1F1E8}\u{1F1ED}','\u{1F1E8}\u{1F1EE}','\u{1F1E8}\u{1F1F0}','\u{1F1E8}\u{1F1F1}','\u{1F1E8}\u{1F1F2}','\u{1F1E8}\u{1F1F3}','\u{1F1E8}\u{1F1F4}','\u{1F1E8}\u{1F1F5}','\u{1F1E8}\u{1F1F6}','\u{1F1E8}\u{1F1F7}','\u{1F1E8}\u{1F1FA}','\u{1F1E8}\u{1F1FB}','\u{1F1E8}\u{1F1FC}','\u{1F1E8}\u{1F1FD}','\u{1F1E8}\u{1F1FE}','\u{1F1E8}\u{1F1FF}','\u{1F1E9}\u{1F1EA}','\u{1F1E9}\u{1F1EC}','\u{1F1E9}\u{1F1EF}','\u{1F1E9}\u{1F1F0}','\u{1F1E9}\u{1F1F2}','\u{1F1E9}\u{1F1F4}','\u{1F1E9}\u{1F1FF}','\u{1F1EA}\u{1F1E6}','\u{1F1EA}\u{1F1E8}','\u{1F1EA}\u{1F1EA}','\u{1F1EA}\u{1F1EC}','\u{1F1EA}\u{1F1ED}','\u{1F1EA}\u{1F1F7}','\u{1F1EA}\u{1F1F8}','\u{1F1EA}\u{1F1F9}','\u{1F1EA}\u{1F1FA}','\u{1F1EB}\u{1F1EE}','\u{1F1EB}\u{1F1EF}','\u{1F1EB}\u{1F1F0}','\u{1F1EB}\u{1F1F2}','\u{1F1EB}\u{1F1F4}','\u{1F1EB}\u{1F1F7}','\u{1F1EC}\u{1F1E6}','\u{1F1EC}\u{1F1E7}','\u{1F1EC}\u{1F1E9}','\u{1F1EC}\u{1F1EA}','\u{1F1EC}\u{1F1EB}','\u{1F1EC}\u{1F1EC}','\u{1F1EC}\u{1F1ED}','\u{1F1EC}\u{1F1EE}','\u{1F1EC}\u{1F1F1}','\u{1F1EC}\u{1F1F2}','\u{1F1EC}\u{1F1F3}','\u{1F1EC}\u{1F1F5}','\u{1F1EC}\u{1F1F6}','\u{1F1EC}\u{1F1F7}','\u{1F1EC}\u{1F1F8}','\u{1F1EC}\u{1F1F9}','\u{1F1EC}\u{1F1FA}','\u{1F1EC}\u{1F1FC}','\u{1F1EC}\u{1F1FE}','\u{1F1ED}\u{1F1F0}','\u{1F1ED}\u{1F1F2}','\u{1F1ED}\u{1F1F3}','\u{1F1ED}\u{1F1F7}','\u{1F1ED}\u{1F1F9}','\u{1F1ED}\u{1F1FA}','\u{1F1EE}\u{1F1E8}','\u{1F1EE}\u{1F1E9}','\u{1F1EE}\u{1F1EA}','\u{1F1EE}\u{1F1F1}','\u{1F1EE}\u{1F1F2}','\u{1F1EE}\u{1F1F3}','\u{1F1EE}\u{1F1F4}','\u{1F1EE}\u{1F1F6}','\u{1F1EE}\u{1F1F7}','\u{1F1EE}\u{1F1F8}','\u{1F1EE}\u{1F1F9}','\u{1F1EF}\u{1F1EA}','\u{1F1EF}\u{1F1F2}','\u{1F1EF}\u{1F1F4}','\u{1F1EF}\u{1F1F5}','\u{1F1F0}\u{1F1EA}','\u{1F1F0}\u{1F1EC}','\u{1F1F0}\u{1F1ED}','\u{1F1F0}\u{1F1EE}','\u{1F1F0}\u{1F1F2}','\u{1F1F0}\u{1F1F3}','\u{1F1F0}\u{1F1F5}','\u{1F1F0}\u{1F1F7}','\u{1F1F0}\u{1F1FC}','\u{1F1F0}\u{1F1FE}','\u{1F1F0}\u{1F1FF}','\u{1F1F1}\u{1F1E6}','\u{1F1F1}\u{1F1E7}','\u{1F1F1}\u{1F1E8}','\u{1F1F1}\u{1F1EE}','\u{1F1F1}\u{1F1F0}','\u{1F1F1}\u{1F1F7}','\u{1F1F1}\u{1F1F8}','\u{1F1F1}\u{1F1F9}','\u{1F1F1}\u{1F1FA}','\u{1F1F1}\u{1F1FB}','\u{1F1F1}\u{1F1FE}','\u{1F1F2}\u{1F1E6}','\u{1F1F2}\u{1F1E8}','\u{1F1F2}\u{1F1E9}','\u{1F1F2}\u{1F1EA}','\u{1F1F2}\u{1F1EB}','\u{1F1F2}\u{1F1EC}','\u{1F1F2}\u{1F1ED}','\u{1F1F2}\u{1F1F0}','\u{1F1F2}\u{1F1F1}','\u{1F1F2}\u{1F1F2}','\u{1F1F2}\u{1F1F3}','\u{1F1F2}\u{1F1F4}','\u{1F1F2}\u{1F1F5}','\u{1F1F2}\u{1F1F6}','\u{1F1F2}\u{1F1F7}','\u{1F1F2}\u{1F1F8}','\u{1F1F2}\u{1F1F9}','\u{1F1F2}\u{1F1FA}','\u{1F1F2}\u{1F1FB}','\u{1F1F2}\u{1F1FC}','\u{1F1F2}\u{1F1FD}','\u{1F1F2}\u{1F1FE}','\u{1F1F2}\u{1F1FF}','\u{1F1F3}\u{1F1E6}','\u{1F1F3}\u{1F1E8}','\u{1F1F3}\u{1F1EA}','\u{1F1F3}\u{1F1EB}','\u{1F1F3}\u{1F1EC}','\u{1F1F3}\u{1F1EE}','\u{1F1F3}\u{1F1F1}','\u{1F1F3}\u{1F1F4}','\u{1F1F3}\u{1F1F5}','\u{1F1F3}\u{1F1F7}','\u{1F1F3}\u{1F1FA}','\u{1F1F3}\u{1F1FF}','\u{1F1F4}\u{1F1F2}','\u{1F1F5}\u{1F1E6}','\u{1F1F5}\u{1F1EA}','\u{1F1F5}\u{1F1EB}','\u{1F1F5}\u{1F1EC}','\u{1F1F5}\u{1F1ED}','\u{1F1F5}\u{1F1F0}','\u{1F1F5}\u{1F1F1}','\u{1F1F5}\u{1F1F2}','\u{1F1F5}\u{1F1F3}','\u{1F1F5}\u{1F1F7}','\u{1F1F5}\u{1F1F8}','\u{1F1F5}\u{1F1F9}','\u{1F1F5}\u{1F1FC}','\u{1F1F5}\u{1F1FE}','\u{1F1F6}\u{1F1E6}','\u{1F1F7}\u{1F1EA}','\u{1F1F7}\u{1F1F4}','\u{1F1F7}\u{1F1F8}','\u{1F1F7}\u{1F1FA}','\u{1F1F7}\u{1F1FC}','\u{1F1F8}\u{1F1E6}','\u{1F1F8}\u{1F1E7}','\u{1F1F8}\u{1F1E8}','\u{1F1F8}\u{1F1E9}','\u{1F1F8}\u{1F1EA}','\u{1F1F8}\u{1F1EC}','\u{1F1F8}\u{1F1ED}','\u{1F1F8}\u{1F1EE}','\u{1F1F8}\u{1F1EF}','\u{1F1F8}\u{1F1F0}','\u{1F1F8}\u{1F1F1}','\u{1F1F8}\u{1F1F2}','\u{1F1F8}\u{1F1F3}','\u{1F1F8}\u{1F1F4}','\u{1F1F8}\u{1F1F7}','\u{1F1F8}\u{1F1F8}','\u{1F1F8}\u{1F1F9}','\u{1F1F8}\u{1F1FB}','\u{1F1F8}\u{1F1FD}','\u{1F1F8}\u{1F1FE}','\u{1F1F8}\u{1F1FF}','\u{1F1F9}\u{1F1E6}','\u{1F1F9}\u{1F1E8}','\u{1F1F9}\u{1F1E9}','\u{1F1F9}\u{1F1EB}','\u{1F1F9}\u{1F1EC}','\u{1F1F9}\u{1F1ED}','\u{1F1F9}\u{1F1EF}','\u{1F1F9}\u{1F1F0}','\u{1F1F9}\u{1F1F1}','\u{1F1F9}\u{1F1F2}','\u{1F1F9}\u{1F1F3}','\u{1F1F9}\u{1F1F4}','\u{1F1F9}\u{1F1F7}','\u{1F1F9}\u{1F1F9}','\u{1F1F9}\u{1F1FB}','\u{1F1F9}\u{1F1FC}','\u{1F1F9}\u{1F1FF}','\u{1F1FA}\u{1F1E6}','\u{1F1FA}\u{1F1EC}','\u{1F1FA}\u{1F1F2}','\u{1F1FA}\u{1F1F3}','\u{1F1FA}\u{1F1F8}','\u{1F1FA}\u{1F1FE}','\u{1F1FA}\u{1F1FF}','\u{1F1FB}\u{1F1E6}','\u{1F1FB}\u{1F1E8}','\u{1F1FB}\u{1F1EA}','\u{1F1FB}\u{1F1EC}','\u{1F1FB}\u{1F1EE}','\u{1F1FB}\u{1F1F3}','\u{1F1FB}\u{1F1FA}','\u{1F1FC}\u{1F1EB}','\u{1F1FC}\u{1F1F8}','\u{1F1FD}\u{1F1F0}','\u{1F1FE}\u{1F1EA}','\u{1F1FE}\u{1F1F9}','\u{1F1FF}\u{1F1E6}','\u{1F1FF}\u{1F1F2}','\u{1F1FF}\u{1F1FC}','\u{1F202}\uFE0F','\u{1F237}\uFE0F','\u{1F321}\uFE0F','\u{1F324}\uFE0F','\u{1F325}\uFE0F','\u{1F326}\uFE0F','\u{1F327}\uFE0F','\u{1F328}\uFE0F','\u{1F329}\uFE0F','\u{1F32A}\uFE0F','\u{1F32B}\uFE0F','\u{1F32C}\uFE0F','\u{1F336}\uFE0F','\u{1F344}\u200D\u{1F7EB}','\u{1F34B}\u200D\u{1F7E9}','\u{1F37D}\uFE0F','\u{1F385}\u{1F3FB}','\u{1F385}\u{1F3FC}','\u{1F385}\u{1F3FD}','\u{1F385}\u{1F3FE}','\u{1F385}\u{1F3FF}','\u{1F396}\uFE0F','\u{1F397}\uFE0F','\u{1F399}\uFE0F','\u{1F39A}\uFE0F','\u{1F39B}\uFE0F','\u{1F39E}\uFE0F','\u{1F39F}\uFE0F','\u{1F3C2}\u{1F3FB}','\u{1F3C2}\u{1F3FC}','\u{1F3C2}\u{1F3FD}','\u{1F3C2}\u{1F3FE}','\u{1F3C2}\u{1F3FF}','\u{1F3C3}\u200D\u2640\uFE0F','\u{1F3C3}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u200D\u2642\uFE0F','\u{1F3C3}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FB}','\u{1F3C3}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F3C3}\u{1F3FB}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F3C3}\u{1F3FB}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FB}\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FC}','\u{1F3C3}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F3C3}\u{1F3FC}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F3C3}\u{1F3FC}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FC}\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FD}','\u{1F3C3}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F3C3}\u{1F3FD}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F3C3}\u{1F3FD}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FD}\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FE}','\u{1F3C3}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F3C3}\u{1F3FE}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F3C3}\u{1F3FE}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FE}\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FF}','\u{1F3C3}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F3C3}\u{1F3FF}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F3C3}\u{1F3FF}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FF}\u200D\u27A1\uFE0F','\u{1F3C4}\u200D\u2640\uFE0F','\u{1F3C4}\u200D\u2642\uFE0F','\u{1F3C4}\u{1F3FB}','\u{1F3C4}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F3C4}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F3C4}\u{1F3FC}','\u{1F3C4}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F3C4}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F3C4}\u{1F3FD}','\u{1F3C4}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F3C4}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F3C4}\u{1F3FE}','\u{1F3C4}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F3C4}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F3C4}\u{1F3FF}','\u{1F3C4}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F3C4}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F3C7}\u{1F3FB}','\u{1F3C7}\u{1F3FC}','\u{1F3C7}\u{1F3FD}','\u{1F3C7}\u{1F3FE}','\u{1F3C7}\u{1F3FF}','\u{1F3CA}\u200D\u2640\uFE0F','\u{1F3CA}\u200D\u2642\uFE0F','\u{1F3CA}\u{1F3FB}','\u{1F3CA}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F3CA}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F3CA}\u{1F3FC}','\u{1F3CA}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F3CA}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F3CA}\u{1F3FD}','\u{1F3CA}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F3CA}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F3CA}\u{1F3FE}','\u{1F3CA}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F3CA}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F3CA}\u{1F3FF}','\u{1F3CA}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F3CA}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F3CB}\u{1F3FB}','\u{1F3CB}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F3CB}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F3CB}\u{1F3FC}','\u{1F3CB}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F3CB}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F3CB}\u{1F3FD}','\u{1F3CB}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F3CB}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F3CB}\u{1F3FE}','\u{1F3CB}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F3CB}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F3CB}\u{1F3FF}','\u{1F3CB}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F3CB}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F3CB}\uFE0F','\u{1F3CB}\uFE0F\u200D\u2640\uFE0F','\u{1F3CB}\uFE0F\u200D\u2642\uFE0F','\u{1F3CC}\u{1F3FB}','\u{1F3CC}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F3CC}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F3CC}\u{1F3FC}','\u{1F3CC}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F3CC}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F3CC}\u{1F3FD}','\u{1F3CC}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F3CC}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F3CC}\u{1F3FE}','\u{1F3CC}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F3CC}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F3CC}\u{1F3FF}','\u{1F3CC}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F3CC}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F3CC}\uFE0F','\u{1F3CC}\uFE0F\u200D\u2640\uFE0F','\u{1F3CC}\uFE0F\u200D\u2642\uFE0F','\u{1F3CD}\uFE0F','\u{1F3CE}\uFE0F','\u{1F3D4}\uFE0F','\u{1F3D5}\uFE0F','\u{1F3D6}\uFE0F','\u{1F3D7}\uFE0F','\u{1F3D8}\uFE0F','\u{1F3D9}\uFE0F','\u{1F3DA}\uFE0F','\u{1F3DB}\uFE0F','\u{1F3DC}\uFE0F','\u{1F3DD}\uFE0F','\u{1F3DE}\uFE0F','\u{1F3DF}\uFE0F','\u{1F3F3}\uFE0F','\u{1F3F3}\uFE0F\u200D\u26A7\uFE0F','\u{1F3F3}\uFE0F\u200D\u{1F308}','\u{1F3F4}\u200D\u2620\uFE0F','\u{1F3F4}\u{E0067}\u{E0062}\u{E0065}\u{E006E}\u{E0067}\u{E007F}','\u{1F3F4}\u{E0067}\u{E0062}\u{E0073}\u{E0063}\u{E0074}\u{E007F}','\u{1F3F4}\u{E0067}\u{E0062}\u{E0077}\u{E006C}\u{E0073}\u{E007F}','\u{1F3F5}\uFE0F','\u{1F3F7}\uFE0F','\u{1F408}\u200D\u2B1B','\u{1F415}\u200D\u{1F9BA}','\u{1F426}\u200D\u2B1B','\u{1F426}\u200D\u{1F525}','\u{1F43B}\u200D\u2744\uFE0F','\u{1F43F}\uFE0F','\u{1F441}\uFE0F','\u{1F441}\uFE0F\u200D\u{1F5E8}\uFE0F','\u{1F442}\u{1F3FB}','\u{1F442}\u{1F3FC}','\u{1F442}\u{1F3FD}','\u{1F442}\u{1F3FE}','\u{1F442}\u{1F3FF}','\u{1F443}\u{1F3FB}','\u{1F443}\u{1F3FC}','\u{1F443}\u{1F3FD}','\u{1F443}\u{1F3FE}','\u{1F443}\u{1F3FF}','\u{1F446}\u{1F3FB}','\u{1F446}\u{1F3FC}','\u{1F446}\u{1F3FD}','\u{1F446}\u{1F3FE}','\u{1F446}\u{1F3FF}','\u{1F447}\u{1F3FB}','\u{1F447}\u{1F3FC}','\u{1F447}\u{1F3FD}','\u{1F447}\u{1F3FE}','\u{1F447}\u{1F3FF}','\u{1F448}\u{1F3FB}','\u{1F448}\u{1F3FC}','\u{1F448}\u{1F3FD}','\u{1F448}\u{1F3FE}','\u{1F448}\u{1F3FF}','\u{1F449}\u{1F3FB}','\u{1F449}\u{1F3FC}','\u{1F449}\u{1F3FD}','\u{1F449}\u{1F3FE}','\u{1F449}\u{1F3FF}','\u{1F44A}\u{1F3FB}','\u{1F44A}\u{1F3FC}','\u{1F44A}\u{1F3FD}','\u{1F44A}\u{1F3FE}','\u{1F44A}\u{1F3FF}','\u{1F44B}\u{1F3FB}','\u{1F44B}\u{1F3FC}','\u{1F44B}\u{1F3FD}','\u{1F44B}\u{1F3FE}','\u{1F44B}\u{1F3FF}','\u{1F44C}\u{1F3FB}','\u{1F44C}\u{1F3FC}','\u{1F44C}\u{1F3FD}','\u{1F44C}\u{1F3FE}','\u{1F44C}\u{1F3FF}','\u{1F44D}\u{1F3FB}','\u{1F44D}\u{1F3FC}','\u{1F44D}\u{1F3FD}','\u{1F44D}\u{1F3FE}','\u{1F44D}\u{1F3FF}','\u{1F44E}\u{1F3FB}','\u{1F44E}\u{1F3FC}','\u{1F44E}\u{1F3FD}','\u{1F44E}\u{1F3FE}','\u{1F44E}\u{1F3FF}','\u{1F44F}\u{1F3FB}','\u{1F44F}\u{1F3FC}','\u{1F44F}\u{1F3FD}','\u{1F44F}\u{1F3FE}','\u{1F44F}\u{1F3FF}','\u{1F450}\u{1F3FB}','\u{1F450}\u{1F3FC}','\u{1F450}\u{1F3FD}','\u{1F450}\u{1F3FE}','\u{1F450}\u{1F3FF}','\u{1F466}\u{1F3FB}','\u{1F466}\u{1F3FC}','\u{1F466}\u{1F3FD}','\u{1F466}\u{1F3FE}','\u{1F466}\u{1F3FF}','\u{1F467}\u{1F3FB}','\u{1F467}\u{1F3FC}','\u{1F467}\u{1F3FD}','\u{1F467}\u{1F3FE}','\u{1F467}\u{1F3FF}','\u{1F468}\u200D\u2695\uFE0F','\u{1F468}\u200D\u2696\uFE0F','\u{1F468}\u200D\u2708\uFE0F','\u{1F468}\u200D\u2764\uFE0F\u200D\u{1F468}','\u{1F468}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}','\u{1F468}\u200D\u{1F33E}','\u{1F468}\u200D\u{1F373}','\u{1F468}\u200D\u{1F37C}','\u{1F468}\u200D\u{1F393}','\u{1F468}\u200D\u{1F3A4}','\u{1F468}\u200D\u{1F3A8}','\u{1F468}\u200D\u{1F3EB}','\u{1F468}\u200D\u{1F3ED}','\u{1F468}\u200D\u{1F466}','\u{1F468}\u200D\u{1F466}\u200D\u{1F466}','\u{1F468}\u200D\u{1F467}','\u{1F468}\u200D\u{1F467}\u200D\u{1F466}','\u{1F468}\u200D\u{1F467}\u200D\u{1F467}','\u{1F468}\u200D\u{1F468}\u200D\u{1F466}','\u{1F468}\u200D\u{1F468}\u200D\u{1F466}\u200D\u{1F466}','\u{1F468}\u200D\u{1F468}\u200D\u{1F467}','\u{1F468}\u200D\u{1F468}\u200D\u{1F467}\u200D\u{1F466}','\u{1F468}\u200D\u{1F468}\u200D\u{1F467}\u200D\u{1F467}','\u{1F468}\u200D\u{1F469}\u200D\u{1F466}','\u{1F468}\u200D\u{1F469}\u200D\u{1F466}\u200D\u{1F466}','\u{1F468}\u200D\u{1F469}\u200D\u{1F467}','\u{1F468}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F466}','\u{1F468}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F467}','\u{1F468}\u200D\u{1F4BB}','\u{1F468}\u200D\u{1F4BC}','\u{1F468}\u200D\u{1F527}','\u{1F468}\u200D\u{1F52C}','\u{1F468}\u200D\u{1F680}','\u{1F468}\u200D\u{1F692}','\u{1F468}\u200D\u{1F9AF}','\u{1F468}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F468}\u200D\u{1F9B0}','\u{1F468}\u200D\u{1F9B1}','\u{1F468}\u200D\u{1F9B2}','\u{1F468}\u200D\u{1F9B3}','\u{1F468}\u200D\u{1F9BC}','\u{1F468}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F468}\u200D\u{1F9BD}','\u{1F468}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FB}\u200D\u2695\uFE0F','\u{1F468}\u{1F3FB}\u200D\u2696\uFE0F','\u{1F468}\u{1F3FB}\u200D\u2708\uFE0F','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FB}\u200D\u{1F33E}','\u{1F468}\u{1F3FB}\u200D\u{1F373}','\u{1F468}\u{1F3FB}\u200D\u{1F37C}','\u{1F468}\u{1F3FB}\u200D\u{1F393}','\u{1F468}\u{1F3FB}\u200D\u{1F3A4}','\u{1F468}\u{1F3FB}\u200D\u{1F3A8}','\u{1F468}\u{1F3FB}\u200D\u{1F3EB}','\u{1F468}\u{1F3FB}\u200D\u{1F3ED}','\u{1F468}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FB}\u200D\u{1F4BB}','\u{1F468}\u{1F3FB}\u200D\u{1F4BC}','\u{1F468}\u{1F3FB}\u200D\u{1F527}','\u{1F468}\u{1F3FB}\u200D\u{1F52C}','\u{1F468}\u{1F3FB}\u200D\u{1F680}','\u{1F468}\u{1F3FB}\u200D\u{1F692}','\u{1F468}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FB}\u200D\u{1F9AF}','\u{1F468}\u{1F3FB}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FB}\u200D\u{1F9B0}','\u{1F468}\u{1F3FB}\u200D\u{1F9B1}','\u{1F468}\u{1F3FB}\u200D\u{1F9B2}','\u{1F468}\u{1F3FB}\u200D\u{1F9B3}','\u{1F468}\u{1F3FB}\u200D\u{1F9BC}','\u{1F468}\u{1F3FB}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FB}\u200D\u{1F9BD}','\u{1F468}\u{1F3FB}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FC}\u200D\u2695\uFE0F','\u{1F468}\u{1F3FC}\u200D\u2696\uFE0F','\u{1F468}\u{1F3FC}\u200D\u2708\uFE0F','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FC}\u200D\u{1F33E}','\u{1F468}\u{1F3FC}\u200D\u{1F373}','\u{1F468}\u{1F3FC}\u200D\u{1F37C}','\u{1F468}\u{1F3FC}\u200D\u{1F393}','\u{1F468}\u{1F3FC}\u200D\u{1F3A4}','\u{1F468}\u{1F3FC}\u200D\u{1F3A8}','\u{1F468}\u{1F3FC}\u200D\u{1F3EB}','\u{1F468}\u{1F3FC}\u200D\u{1F3ED}','\u{1F468}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FC}\u200D\u{1F4BB}','\u{1F468}\u{1F3FC}\u200D\u{1F4BC}','\u{1F468}\u{1F3FC}\u200D\u{1F527}','\u{1F468}\u{1F3FC}\u200D\u{1F52C}','\u{1F468}\u{1F3FC}\u200D\u{1F680}','\u{1F468}\u{1F3FC}\u200D\u{1F692}','\u{1F468}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FC}\u200D\u{1F9AF}','\u{1F468}\u{1F3FC}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FC}\u200D\u{1F9B0}','\u{1F468}\u{1F3FC}\u200D\u{1F9B1}','\u{1F468}\u{1F3FC}\u200D\u{1F9B2}','\u{1F468}\u{1F3FC}\u200D\u{1F9B3}','\u{1F468}\u{1F3FC}\u200D\u{1F9BC}','\u{1F468}\u{1F3FC}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FC}\u200D\u{1F9BD}','\u{1F468}\u{1F3FC}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FD}\u200D\u2695\uFE0F','\u{1F468}\u{1F3FD}\u200D\u2696\uFE0F','\u{1F468}\u{1F3FD}\u200D\u2708\uFE0F','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FD}\u200D\u{1F33E}','\u{1F468}\u{1F3FD}\u200D\u{1F373}','\u{1F468}\u{1F3FD}\u200D\u{1F37C}','\u{1F468}\u{1F3FD}\u200D\u{1F393}','\u{1F468}\u{1F3FD}\u200D\u{1F3A4}','\u{1F468}\u{1F3FD}\u200D\u{1F3A8}','\u{1F468}\u{1F3FD}\u200D\u{1F3EB}','\u{1F468}\u{1F3FD}\u200D\u{1F3ED}','\u{1F468}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FD}\u200D\u{1F4BB}','\u{1F468}\u{1F3FD}\u200D\u{1F4BC}','\u{1F468}\u{1F3FD}\u200D\u{1F527}','\u{1F468}\u{1F3FD}\u200D\u{1F52C}','\u{1F468}\u{1F3FD}\u200D\u{1F680}','\u{1F468}\u{1F3FD}\u200D\u{1F692}','\u{1F468}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FD}\u200D\u{1F9AF}','\u{1F468}\u{1F3FD}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FD}\u200D\u{1F9B0}','\u{1F468}\u{1F3FD}\u200D\u{1F9B1}','\u{1F468}\u{1F3FD}\u200D\u{1F9B2}','\u{1F468}\u{1F3FD}\u200D\u{1F9B3}','\u{1F468}\u{1F3FD}\u200D\u{1F9BC}','\u{1F468}\u{1F3FD}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FD}\u200D\u{1F9BD}','\u{1F468}\u{1F3FD}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FE}\u200D\u2695\uFE0F','\u{1F468}\u{1F3FE}\u200D\u2696\uFE0F','\u{1F468}\u{1F3FE}\u200D\u2708\uFE0F','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FE}\u200D\u{1F33E}','\u{1F468}\u{1F3FE}\u200D\u{1F373}','\u{1F468}\u{1F3FE}\u200D\u{1F37C}','\u{1F468}\u{1F3FE}\u200D\u{1F393}','\u{1F468}\u{1F3FE}\u200D\u{1F3A4}','\u{1F468}\u{1F3FE}\u200D\u{1F3A8}','\u{1F468}\u{1F3FE}\u200D\u{1F3EB}','\u{1F468}\u{1F3FE}\u200D\u{1F3ED}','\u{1F468}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FE}\u200D\u{1F4BB}','\u{1F468}\u{1F3FE}\u200D\u{1F4BC}','\u{1F468}\u{1F3FE}\u200D\u{1F527}','\u{1F468}\u{1F3FE}\u200D\u{1F52C}','\u{1F468}\u{1F3FE}\u200D\u{1F680}','\u{1F468}\u{1F3FE}\u200D\u{1F692}','\u{1F468}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FE}\u200D\u{1F9AF}','\u{1F468}\u{1F3FE}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FE}\u200D\u{1F9B0}','\u{1F468}\u{1F3FE}\u200D\u{1F9B1}','\u{1F468}\u{1F3FE}\u200D\u{1F9B2}','\u{1F468}\u{1F3FE}\u200D\u{1F9B3}','\u{1F468}\u{1F3FE}\u200D\u{1F9BC}','\u{1F468}\u{1F3FE}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FE}\u200D\u{1F9BD}','\u{1F468}\u{1F3FE}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FF}\u200D\u2695\uFE0F','\u{1F468}\u{1F3FF}\u200D\u2696\uFE0F','\u{1F468}\u{1F3FF}\u200D\u2708\uFE0F','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FF}\u200D\u{1F33E}','\u{1F468}\u{1F3FF}\u200D\u{1F373}','\u{1F468}\u{1F3FF}\u200D\u{1F37C}','\u{1F468}\u{1F3FF}\u200D\u{1F393}','\u{1F468}\u{1F3FF}\u200D\u{1F3A4}','\u{1F468}\u{1F3FF}\u200D\u{1F3A8}','\u{1F468}\u{1F3FF}\u200D\u{1F3EB}','\u{1F468}\u{1F3FF}\u200D\u{1F3ED}','\u{1F468}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FF}\u200D\u{1F4BB}','\u{1F468}\u{1F3FF}\u200D\u{1F4BC}','\u{1F468}\u{1F3FF}\u200D\u{1F527}','\u{1F468}\u{1F3FF}\u200D\u{1F52C}','\u{1F468}\u{1F3FF}\u200D\u{1F680}','\u{1F468}\u{1F3FF}\u200D\u{1F692}','\u{1F468}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FF}\u200D\u{1F9AF}','\u{1F468}\u{1F3FF}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FF}\u200D\u{1F9B0}','\u{1F468}\u{1F3FF}\u200D\u{1F9B1}','\u{1F468}\u{1F3FF}\u200D\u{1F9B2}','\u{1F468}\u{1F3FF}\u200D\u{1F9B3}','\u{1F468}\u{1F3FF}\u200D\u{1F9BC}','\u{1F468}\u{1F3FF}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FF}\u200D\u{1F9BD}','\u{1F468}\u{1F3FF}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u200D\u2695\uFE0F','\u{1F469}\u200D\u2696\uFE0F','\u{1F469}\u200D\u2708\uFE0F','\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F468}','\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F469}','\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}','\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}','\u{1F469}\u200D\u{1F33E}','\u{1F469}\u200D\u{1F373}','\u{1F469}\u200D\u{1F37C}','\u{1F469}\u200D\u{1F393}','\u{1F469}\u200D\u{1F3A4}','\u{1F469}\u200D\u{1F3A8}','\u{1F469}\u200D\u{1F3EB}','\u{1F469}\u200D\u{1F3ED}','\u{1F469}\u200D\u{1F466}','\u{1F469}\u200D\u{1F466}\u200D\u{1F466}','\u{1F469}\u200D\u{1F467}','\u{1F469}\u200D\u{1F467}\u200D\u{1F466}','\u{1F469}\u200D\u{1F467}\u200D\u{1F467}','\u{1F469}\u200D\u{1F469}\u200D\u{1F466}','\u{1F469}\u200D\u{1F469}\u200D\u{1F466}\u200D\u{1F466}','\u{1F469}\u200D\u{1F469}\u200D\u{1F467}','\u{1F469}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F466}','\u{1F469}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F467}','\u{1F469}\u200D\u{1F4BB}','\u{1F469}\u200D\u{1F4BC}','\u{1F469}\u200D\u{1F527}','\u{1F469}\u200D\u{1F52C}','\u{1F469}\u200D\u{1F680}','\u{1F469}\u200D\u{1F692}','\u{1F469}\u200D\u{1F9AF}','\u{1F469}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F469}\u200D\u{1F9B0}','\u{1F469}\u200D\u{1F9B1}','\u{1F469}\u200D\u{1F9B2}','\u{1F469}\u200D\u{1F9B3}','\u{1F469}\u200D\u{1F9BC}','\u{1F469}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F469}\u200D\u{1F9BD}','\u{1F469}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FB}\u200D\u2695\uFE0F','\u{1F469}\u{1F3FB}\u200D\u2696\uFE0F','\u{1F469}\u{1F3FB}\u200D\u2708\uFE0F','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u{1F33E}','\u{1F469}\u{1F3FB}\u200D\u{1F373}','\u{1F469}\u{1F3FB}\u200D\u{1F37C}','\u{1F469}\u{1F3FB}\u200D\u{1F393}','\u{1F469}\u{1F3FB}\u200D\u{1F3A4}','\u{1F469}\u{1F3FB}\u200D\u{1F3A8}','\u{1F469}\u{1F3FB}\u200D\u{1F3EB}','\u{1F469}\u{1F3FB}\u200D\u{1F3ED}','\u{1F469}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u{1F4BB}','\u{1F469}\u{1F3FB}\u200D\u{1F4BC}','\u{1F469}\u{1F3FB}\u200D\u{1F527}','\u{1F469}\u{1F3FB}\u200D\u{1F52C}','\u{1F469}\u{1F3FB}\u200D\u{1F680}','\u{1F469}\u{1F3FB}\u200D\u{1F692}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u{1F9AF}','\u{1F469}\u{1F3FB}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FB}\u200D\u{1F9B0}','\u{1F469}\u{1F3FB}\u200D\u{1F9B1}','\u{1F469}\u{1F3FB}\u200D\u{1F9B2}','\u{1F469}\u{1F3FB}\u200D\u{1F9B3}','\u{1F469}\u{1F3FB}\u200D\u{1F9BC}','\u{1F469}\u{1F3FB}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FB}\u200D\u{1F9BD}','\u{1F469}\u{1F3FB}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FC}\u200D\u2695\uFE0F','\u{1F469}\u{1F3FC}\u200D\u2696\uFE0F','\u{1F469}\u{1F3FC}\u200D\u2708\uFE0F','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u{1F33E}','\u{1F469}\u{1F3FC}\u200D\u{1F373}','\u{1F469}\u{1F3FC}\u200D\u{1F37C}','\u{1F469}\u{1F3FC}\u200D\u{1F393}','\u{1F469}\u{1F3FC}\u200D\u{1F3A4}','\u{1F469}\u{1F3FC}\u200D\u{1F3A8}','\u{1F469}\u{1F3FC}\u200D\u{1F3EB}','\u{1F469}\u{1F3FC}\u200D\u{1F3ED}','\u{1F469}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u{1F4BB}','\u{1F469}\u{1F3FC}\u200D\u{1F4BC}','\u{1F469}\u{1F3FC}\u200D\u{1F527}','\u{1F469}\u{1F3FC}\u200D\u{1F52C}','\u{1F469}\u{1F3FC}\u200D\u{1F680}','\u{1F469}\u{1F3FC}\u200D\u{1F692}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u{1F9AF}','\u{1F469}\u{1F3FC}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FC}\u200D\u{1F9B0}','\u{1F469}\u{1F3FC}\u200D\u{1F9B1}','\u{1F469}\u{1F3FC}\u200D\u{1F9B2}','\u{1F469}\u{1F3FC}\u200D\u{1F9B3}','\u{1F469}\u{1F3FC}\u200D\u{1F9BC}','\u{1F469}\u{1F3FC}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FC}\u200D\u{1F9BD}','\u{1F469}\u{1F3FC}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FD}\u200D\u2695\uFE0F','\u{1F469}\u{1F3FD}\u200D\u2696\uFE0F','\u{1F469}\u{1F3FD}\u200D\u2708\uFE0F','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u{1F33E}','\u{1F469}\u{1F3FD}\u200D\u{1F373}','\u{1F469}\u{1F3FD}\u200D\u{1F37C}','\u{1F469}\u{1F3FD}\u200D\u{1F393}','\u{1F469}\u{1F3FD}\u200D\u{1F3A4}','\u{1F469}\u{1F3FD}\u200D\u{1F3A8}','\u{1F469}\u{1F3FD}\u200D\u{1F3EB}','\u{1F469}\u{1F3FD}\u200D\u{1F3ED}','\u{1F469}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u{1F4BB}','\u{1F469}\u{1F3FD}\u200D\u{1F4BC}','\u{1F469}\u{1F3FD}\u200D\u{1F527}','\u{1F469}\u{1F3FD}\u200D\u{1F52C}','\u{1F469}\u{1F3FD}\u200D\u{1F680}','\u{1F469}\u{1F3FD}\u200D\u{1F692}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u{1F9AF}','\u{1F469}\u{1F3FD}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FD}\u200D\u{1F9B0}','\u{1F469}\u{1F3FD}\u200D\u{1F9B1}','\u{1F469}\u{1F3FD}\u200D\u{1F9B2}','\u{1F469}\u{1F3FD}\u200D\u{1F9B3}','\u{1F469}\u{1F3FD}\u200D\u{1F9BC}','\u{1F469}\u{1F3FD}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FD}\u200D\u{1F9BD}','\u{1F469}\u{1F3FD}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FE}\u200D\u2695\uFE0F','\u{1F469}\u{1F3FE}\u200D\u2696\uFE0F','\u{1F469}\u{1F3FE}\u200D\u2708\uFE0F','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u{1F33E}','\u{1F469}\u{1F3FE}\u200D\u{1F373}','\u{1F469}\u{1F3FE}\u200D\u{1F37C}','\u{1F469}\u{1F3FE}\u200D\u{1F393}','\u{1F469}\u{1F3FE}\u200D\u{1F3A4}','\u{1F469}\u{1F3FE}\u200D\u{1F3A8}','\u{1F469}\u{1F3FE}\u200D\u{1F3EB}','\u{1F469}\u{1F3FE}\u200D\u{1F3ED}','\u{1F469}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u{1F4BB}','\u{1F469}\u{1F3FE}\u200D\u{1F4BC}','\u{1F469}\u{1F3FE}\u200D\u{1F527}','\u{1F469}\u{1F3FE}\u200D\u{1F52C}','\u{1F469}\u{1F3FE}\u200D\u{1F680}','\u{1F469}\u{1F3FE}\u200D\u{1F692}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u{1F9AF}','\u{1F469}\u{1F3FE}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FE}\u200D\u{1F9B0}','\u{1F469}\u{1F3FE}\u200D\u{1F9B1}','\u{1F469}\u{1F3FE}\u200D\u{1F9B2}','\u{1F469}\u{1F3FE}\u200D\u{1F9B3}','\u{1F469}\u{1F3FE}\u200D\u{1F9BC}','\u{1F469}\u{1F3FE}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FE}\u200D\u{1F9BD}','\u{1F469}\u{1F3FE}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FF}\u200D\u2695\uFE0F','\u{1F469}\u{1F3FF}\u200D\u2696\uFE0F','\u{1F469}\u{1F3FF}\u200D\u2708\uFE0F','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FF}\u200D\u{1F33E}','\u{1F469}\u{1F3FF}\u200D\u{1F373}','\u{1F469}\u{1F3FF}\u200D\u{1F37C}','\u{1F469}\u{1F3FF}\u200D\u{1F393}','\u{1F469}\u{1F3FF}\u200D\u{1F3A4}','\u{1F469}\u{1F3FF}\u200D\u{1F3A8}','\u{1F469}\u{1F3FF}\u200D\u{1F3EB}','\u{1F469}\u{1F3FF}\u200D\u{1F3ED}','\u{1F469}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u{1F4BB}','\u{1F469}\u{1F3FF}\u200D\u{1F4BC}','\u{1F469}\u{1F3FF}\u200D\u{1F527}','\u{1F469}\u{1F3FF}\u200D\u{1F52C}','\u{1F469}\u{1F3FF}\u200D\u{1F680}','\u{1F469}\u{1F3FF}\u200D\u{1F692}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u{1F9AF}','\u{1F469}\u{1F3FF}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FF}\u200D\u{1F9B0}','\u{1F469}\u{1F3FF}\u200D\u{1F9B1}','\u{1F469}\u{1F3FF}\u200D\u{1F9B2}','\u{1F469}\u{1F3FF}\u200D\u{1F9B3}','\u{1F469}\u{1F3FF}\u200D\u{1F9BC}','\u{1F469}\u{1F3FF}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FF}\u200D\u{1F9BD}','\u{1F469}\u{1F3FF}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FE}','\u{1F46B}\u{1F3FB}','\u{1F46B}\u{1F3FC}','\u{1F46B}\u{1F3FD}','\u{1F46B}\u{1F3FE}','\u{1F46B}\u{1F3FF}','\u{1F46C}\u{1F3FB}','\u{1F46C}\u{1F3FC}','\u{1F46C}\u{1F3FD}','\u{1F46C}\u{1F3FE}','\u{1F46C}\u{1F3FF}','\u{1F46D}\u{1F3FB}','\u{1F46D}\u{1F3FC}','\u{1F46D}\u{1F3FD}','\u{1F46D}\u{1F3FE}','\u{1F46D}\u{1F3FF}','\u{1F46E}\u200D\u2640\uFE0F','\u{1F46E}\u200D\u2642\uFE0F','\u{1F46E}\u{1F3FB}','\u{1F46E}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F46E}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F46E}\u{1F3FC}','\u{1F46E}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F46E}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F46E}\u{1F3FD}','\u{1F46E}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F46E}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F46E}\u{1F3FE}','\u{1F46E}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F46E}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F46E}\u{1F3FF}','\u{1F46E}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F46E}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F46F}\u200D\u2640\uFE0F','\u{1F46F}\u200D\u2642\uFE0F','\u{1F46F}\u{1F3FB}','\u{1F46F}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F46F}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F46F}\u{1F3FC}','\u{1F46F}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F46F}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F46F}\u{1F3FD}','\u{1F46F}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F46F}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F46F}\u{1F3FE}','\u{1F46F}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F46F}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F46F}\u{1F3FF}','\u{1F46F}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F46F}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F470}\u200D\u2640\uFE0F','\u{1F470}\u200D\u2642\uFE0F','\u{1F470}\u{1F3FB}','\u{1F470}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F470}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F470}\u{1F3FC}','\u{1F470}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F470}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F470}\u{1F3FD}','\u{1F470}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F470}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F470}\u{1F3FE}','\u{1F470}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F470}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F470}\u{1F3FF}','\u{1F470}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F470}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F471}\u200D\u2640\uFE0F','\u{1F471}\u200D\u2642\uFE0F','\u{1F471}\u{1F3FB}','\u{1F471}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F471}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F471}\u{1F3FC}','\u{1F471}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F471}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F471}\u{1F3FD}','\u{1F471}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F471}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F471}\u{1F3FE}','\u{1F471}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F471}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F471}\u{1F3FF}','\u{1F471}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F471}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F472}\u{1F3FB}','\u{1F472}\u{1F3FC}','\u{1F472}\u{1F3FD}','\u{1F472}\u{1F3FE}','\u{1F472}\u{1F3FF}','\u{1F473}\u200D\u2640\uFE0F','\u{1F473}\u200D\u2642\uFE0F','\u{1F473}\u{1F3FB}','\u{1F473}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F473}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F473}\u{1F3FC}','\u{1F473}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F473}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F473}\u{1F3FD}','\u{1F473}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F473}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F473}\u{1F3FE}','\u{1F473}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F473}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F473}\u{1F3FF}','\u{1F473}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F473}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F474}\u{1F3FB}','\u{1F474}\u{1F3FC}','\u{1F474}\u{1F3FD}','\u{1F474}\u{1F3FE}','\u{1F474}\u{1F3FF}','\u{1F475}\u{1F3FB}','\u{1F475}\u{1F3FC}','\u{1F475}\u{1F3FD}','\u{1F475}\u{1F3FE}','\u{1F475}\u{1F3FF}','\u{1F476}\u{1F3FB}','\u{1F476}\u{1F3FC}','\u{1F476}\u{1F3FD}','\u{1F476}\u{1F3FE}','\u{1F476}\u{1F3FF}','\u{1F477}\u200D\u2640\uFE0F','\u{1F477}\u200D\u2642\uFE0F','\u{1F477}\u{1F3FB}','\u{1F477}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F477}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F477}\u{1F3FC}','\u{1F477}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F477}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F477}\u{1F3FD}','\u{1F477}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F477}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F477}\u{1F3FE}','\u{1F477}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F477}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F477}\u{1F3FF}','\u{1F477}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F477}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F478}\u{1F3FB}','\u{1F478}\u{1F3FC}','\u{1F478}\u{1F3FD}','\u{1F478}\u{1F3FE}','\u{1F478}\u{1F3FF}','\u{1F47C}\u{1F3FB}','\u{1F47C}\u{1F3FC}','\u{1F47C}\u{1F3FD}','\u{1F47C}\u{1F3FE}','\u{1F47C}\u{1F3FF}','\u{1F481}\u200D\u2640\uFE0F','\u{1F481}\u200D\u2642\uFE0F','\u{1F481}\u{1F3FB}','\u{1F481}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F481}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F481}\u{1F3FC}','\u{1F481}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F481}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F481}\u{1F3FD}','\u{1F481}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F481}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F481}\u{1F3FE}','\u{1F481}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F481}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F481}\u{1F3FF}','\u{1F481}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F481}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F482}\u200D\u2640\uFE0F','\u{1F482}\u200D\u2642\uFE0F','\u{1F482}\u{1F3FB}','\u{1F482}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F482}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F482}\u{1F3FC}','\u{1F482}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F482}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F482}\u{1F3FD}','\u{1F482}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F482}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F482}\u{1F3FE}','\u{1F482}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F482}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F482}\u{1F3FF}','\u{1F482}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F482}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F483}\u{1F3FB}','\u{1F483}\u{1F3FC}','\u{1F483}\u{1F3FD}','\u{1F483}\u{1F3FE}','\u{1F483}\u{1F3FF}','\u{1F485}\u{1F3FB}','\u{1F485}\u{1F3FC}','\u{1F485}\u{1F3FD}','\u{1F485}\u{1F3FE}','\u{1F485}\u{1F3FF}','\u{1F486}\u200D\u2640\uFE0F','\u{1F486}\u200D\u2642\uFE0F','\u{1F486}\u{1F3FB}','\u{1F486}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F486}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F486}\u{1F3FC}','\u{1F486}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F486}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F486}\u{1F3FD}','\u{1F486}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F486}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F486}\u{1F3FE}','\u{1F486}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F486}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F486}\u{1F3FF}','\u{1F486}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F486}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F487}\u200D\u2640\uFE0F','\u{1F487}\u200D\u2642\uFE0F','\u{1F487}\u{1F3FB}','\u{1F487}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F487}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F487}\u{1F3FC}','\u{1F487}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F487}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F487}\u{1F3FD}','\u{1F487}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F487}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F487}\u{1F3FE}','\u{1F487}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F487}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F487}\u{1F3FF}','\u{1F487}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F487}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F48F}\u{1F3FB}','\u{1F48F}\u{1F3FC}','\u{1F48F}\u{1F3FD}','\u{1F48F}\u{1F3FE}','\u{1F48F}\u{1F3FF}','\u{1F491}\u{1F3FB}','\u{1F491}\u{1F3FC}','\u{1F491}\u{1F3FD}','\u{1F491}\u{1F3FE}','\u{1F491}\u{1F3FF}','\u{1F4AA}\u{1F3FB}','\u{1F4AA}\u{1F3FC}','\u{1F4AA}\u{1F3FD}','\u{1F4AA}\u{1F3FE}','\u{1F4AA}\u{1F3FF}','\u{1F4FD}\uFE0F','\u{1F549}\uFE0F','\u{1F54A}\uFE0F','\u{1F56F}\uFE0F','\u{1F570}\uFE0F','\u{1F573}\uFE0F','\u{1F574}\u{1F3FB}','\u{1F574}\u{1F3FC}','\u{1F574}\u{1F3FD}','\u{1F574}\u{1F3FE}','\u{1F574}\u{1F3FF}','\u{1F574}\uFE0F','\u{1F575}\u{1F3FB}','\u{1F575}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F575}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F575}\u{1F3FC}','\u{1F575}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F575}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F575}\u{1F3FD}','\u{1F575}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F575}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F575}\u{1F3FE}','\u{1F575}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F575}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F575}\u{1F3FF}','\u{1F575}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F575}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F575}\uFE0F','\u{1F575}\uFE0F\u200D\u2640\uFE0F','\u{1F575}\uFE0F\u200D\u2642\uFE0F','\u{1F576}\uFE0F','\u{1F577}\uFE0F','\u{1F578}\uFE0F','\u{1F579}\uFE0F','\u{1F57A}\u{1F3FB}','\u{1F57A}\u{1F3FC}','\u{1F57A}\u{1F3FD}','\u{1F57A}\u{1F3FE}','\u{1F57A}\u{1F3FF}','\u{1F587}\uFE0F','\u{1F58A}\uFE0F','\u{1F58B}\uFE0F','\u{1F58C}\uFE0F','\u{1F58D}\uFE0F','\u{1F590}\u{1F3FB}','\u{1F590}\u{1F3FC}','\u{1F590}\u{1F3FD}','\u{1F590}\u{1F3FE}','\u{1F590}\u{1F3FF}','\u{1F590}\uFE0F','\u{1F595}\u{1F3FB}','\u{1F595}\u{1F3FC}','\u{1F595}\u{1F3FD}','\u{1F595}\u{1F3FE}','\u{1F595}\u{1F3FF}','\u{1F596}\u{1F3FB}','\u{1F596}\u{1F3FC}','\u{1F596}\u{1F3FD}','\u{1F596}\u{1F3FE}','\u{1F596}\u{1F3FF}','\u{1F5A5}\uFE0F','\u{1F5A8}\uFE0F','\u{1F5B1}\uFE0F','\u{1F5B2}\uFE0F','\u{1F5BC}\uFE0F','\u{1F5C2}\uFE0F','\u{1F5C3}\uFE0F','\u{1F5C4}\uFE0F','\u{1F5D1}\uFE0F','\u{1F5D2}\uFE0F','\u{1F5D3}\uFE0F','\u{1F5DC}\uFE0F','\u{1F5DD}\uFE0F','\u{1F5DE}\uFE0F','\u{1F5E1}\uFE0F','\u{1F5E3}\uFE0F','\u{1F5E8}\uFE0F','\u{1F5EF}\uFE0F','\u{1F5F3}\uFE0F','\u{1F5FA}\uFE0F','\u{1F62E}\u200D\u{1F4A8}','\u{1F635}\u200D\u{1F4AB}','\u{1F636}\u200D\u{1F32B}\uFE0F','\u{1F642}\u200D\u2194\uFE0F','\u{1F642}\u200D\u2195\uFE0F','\u{1F645}\u200D\u2640\uFE0F','\u{1F645}\u200D\u2642\uFE0F','\u{1F645}\u{1F3FB}','\u{1F645}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F645}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F645}\u{1F3FC}','\u{1F645}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F645}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F645}\u{1F3FD}','\u{1F645}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F645}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F645}\u{1F3FE}','\u{1F645}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F645}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F645}\u{1F3FF}','\u{1F645}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F645}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F646}\u200D\u2640\uFE0F','\u{1F646}\u200D\u2642\uFE0F','\u{1F646}\u{1F3FB}','\u{1F646}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F646}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F646}\u{1F3FC}','\u{1F646}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F646}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F646}\u{1F3FD}','\u{1F646}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F646}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F646}\u{1F3FE}','\u{1F646}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F646}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F646}\u{1F3FF}','\u{1F646}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F646}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F647}\u200D\u2640\uFE0F','\u{1F647}\u200D\u2642\uFE0F','\u{1F647}\u{1F3FB}','\u{1F647}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F647}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F647}\u{1F3FC}','\u{1F647}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F647}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F647}\u{1F3FD}','\u{1F647}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F647}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F647}\u{1F3FE}','\u{1F647}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F647}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F647}\u{1F3FF}','\u{1F647}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F647}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F64B}\u200D\u2640\uFE0F','\u{1F64B}\u200D\u2642\uFE0F','\u{1F64B}\u{1F3FB}','\u{1F64B}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F64B}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F64B}\u{1F3FC}','\u{1F64B}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F64B}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F64B}\u{1F3FD}','\u{1F64B}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F64B}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F64B}\u{1F3FE}','\u{1F64B}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F64B}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F64B}\u{1F3FF}','\u{1F64B}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F64B}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F64C}\u{1F3FB}','\u{1F64C}\u{1F3FC}','\u{1F64C}\u{1F3FD}','\u{1F64C}\u{1F3FE}','\u{1F64C}\u{1F3FF}','\u{1F64D}\u200D\u2640\uFE0F','\u{1F64D}\u200D\u2642\uFE0F','\u{1F64D}\u{1F3FB}','\u{1F64D}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F64D}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F64D}\u{1F3FC}','\u{1F64D}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F64D}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F64D}\u{1F3FD}','\u{1F64D}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F64D}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F64D}\u{1F3FE}','\u{1F64D}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F64D}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F64D}\u{1F3FF}','\u{1F64D}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F64D}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F64E}\u200D\u2640\uFE0F','\u{1F64E}\u200D\u2642\uFE0F','\u{1F64E}\u{1F3FB}','\u{1F64E}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F64E}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F64E}\u{1F3FC}','\u{1F64E}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F64E}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F64E}\u{1F3FD}','\u{1F64E}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F64E}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F64E}\u{1F3FE}','\u{1F64E}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F64E}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F64E}\u{1F3FF}','\u{1F64E}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F64E}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F64F}\u{1F3FB}','\u{1F64F}\u{1F3FC}','\u{1F64F}\u{1F3FD}','\u{1F64F}\u{1F3FE}','\u{1F64F}\u{1F3FF}','\u{1F6A3}\u200D\u2640\uFE0F','\u{1F6A3}\u200D\u2642\uFE0F','\u{1F6A3}\u{1F3FB}','\u{1F6A3}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F6A3}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F6A3}\u{1F3FC}','\u{1F6A3}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F6A3}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F6A3}\u{1F3FD}','\u{1F6A3}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F6A3}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F6A3}\u{1F3FE}','\u{1F6A3}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F6A3}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F6A3}\u{1F3FF}','\u{1F6A3}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F6A3}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F6B4}\u200D\u2640\uFE0F','\u{1F6B4}\u200D\u2642\uFE0F','\u{1F6B4}\u{1F3FB}','\u{1F6B4}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F6B4}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F6B4}\u{1F3FC}','\u{1F6B4}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F6B4}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F6B4}\u{1F3FD}','\u{1F6B4}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F6B4}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F6B4}\u{1F3FE}','\u{1F6B4}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F6B4}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F6B4}\u{1F3FF}','\u{1F6B4}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F6B4}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F6B5}\u200D\u2640\uFE0F','\u{1F6B5}\u200D\u2642\uFE0F','\u{1F6B5}\u{1F3FB}','\u{1F6B5}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F6B5}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F6B5}\u{1F3FC}','\u{1F6B5}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F6B5}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F6B5}\u{1F3FD}','\u{1F6B5}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F6B5}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F6B5}\u{1F3FE}','\u{1F6B5}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F6B5}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F6B5}\u{1F3FF}','\u{1F6B5}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F6B5}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F6B6}\u200D\u2640\uFE0F','\u{1F6B6}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u200D\u2642\uFE0F','\u{1F6B6}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FB}','\u{1F6B6}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F6B6}\u{1F3FB}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F6B6}\u{1F3FB}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FB}\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FC}','\u{1F6B6}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F6B6}\u{1F3FC}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F6B6}\u{1F3FC}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FC}\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FD}','\u{1F6B6}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F6B6}\u{1F3FD}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F6B6}\u{1F3FD}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FD}\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FE}','\u{1F6B6}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F6B6}\u{1F3FE}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F6B6}\u{1F3FE}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FE}\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FF}','\u{1F6B6}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F6B6}\u{1F3FF}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F6B6}\u{1F3FF}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FF}\u200D\u27A1\uFE0F','\u{1F6C0}\u{1F3FB}','\u{1F6C0}\u{1F3FC}','\u{1F6C0}\u{1F3FD}','\u{1F6C0}\u{1F3FE}','\u{1F6C0}\u{1F3FF}','\u{1F6CB}\uFE0F','\u{1F6CC}\u{1F3FB}','\u{1F6CC}\u{1F3FC}','\u{1F6CC}\u{1F3FD}','\u{1F6CC}\u{1F3FE}','\u{1F6CC}\u{1F3FF}','\u{1F6CD}\uFE0F','\u{1F6CE}\uFE0F','\u{1F6CF}\uFE0F','\u{1F6E0}\uFE0F','\u{1F6E1}\uFE0F','\u{1F6E2}\uFE0F','\u{1F6E3}\uFE0F','\u{1F6E4}\uFE0F','\u{1F6E5}\uFE0F','\u{1F6E9}\uFE0F','\u{1F6F0}\uFE0F','\u{1F6F3}\uFE0F','\u{1F90C}\u{1F3FB}','\u{1F90C}\u{1F3FC}','\u{1F90C}\u{1F3FD}','\u{1F90C}\u{1F3FE}','\u{1F90C}\u{1F3FF}','\u{1F90F}\u{1F3FB}','\u{1F90F}\u{1F3FC}','\u{1F90F}\u{1F3FD}','\u{1F90F}\u{1F3FE}','\u{1F90F}\u{1F3FF}','\u{1F918}\u{1F3FB}','\u{1F918}\u{1F3FC}','\u{1F918}\u{1F3FD}','\u{1F918}\u{1F3FE}','\u{1F918}\u{1F3FF}','\u{1F919}\u{1F3FB}','\u{1F919}\u{1F3FC}','\u{1F919}\u{1F3FD}','\u{1F919}\u{1F3FE}','\u{1F919}\u{1F3FF}','\u{1F91A}\u{1F3FB}','\u{1F91A}\u{1F3FC}','\u{1F91A}\u{1F3FD}','\u{1F91A}\u{1F3FE}','\u{1F91A}\u{1F3FF}','\u{1F91B}\u{1F3FB}','\u{1F91B}\u{1F3FC}','\u{1F91B}\u{1F3FD}','\u{1F91B}\u{1F3FE}','\u{1F91B}\u{1F3FF}','\u{1F91C}\u{1F3FB}','\u{1F91C}\u{1F3FC}','\u{1F91C}\u{1F3FD}','\u{1F91C}\u{1F3FE}','\u{1F91C}\u{1F3FF}','\u{1F91D}\u{1F3FB}','\u{1F91D}\u{1F3FC}','\u{1F91D}\u{1F3FD}','\u{1F91D}\u{1F3FE}','\u{1F91D}\u{1F3FF}','\u{1F91E}\u{1F3FB}','\u{1F91E}\u{1F3FC}','\u{1F91E}\u{1F3FD}','\u{1F91E}\u{1F3FE}','\u{1F91E}\u{1F3FF}','\u{1F91F}\u{1F3FB}','\u{1F91F}\u{1F3FC}','\u{1F91F}\u{1F3FD}','\u{1F91F}\u{1F3FE}','\u{1F91F}\u{1F3FF}','\u{1F926}\u200D\u2640\uFE0F','\u{1F926}\u200D\u2642\uFE0F','\u{1F926}\u{1F3FB}','\u{1F926}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F926}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F926}\u{1F3FC}','\u{1F926}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F926}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F926}\u{1F3FD}','\u{1F926}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F926}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F926}\u{1F3FE}','\u{1F926}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F926}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F926}\u{1F3FF}','\u{1F926}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F926}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F930}\u{1F3FB}','\u{1F930}\u{1F3FC}','\u{1F930}\u{1F3FD}','\u{1F930}\u{1F3FE}','\u{1F930}\u{1F3FF}','\u{1F931}\u{1F3FB}','\u{1F931}\u{1F3FC}','\u{1F931}\u{1F3FD}','\u{1F931}\u{1F3FE}','\u{1F931}\u{1F3FF}','\u{1F932}\u{1F3FB}','\u{1F932}\u{1F3FC}','\u{1F932}\u{1F3FD}','\u{1F932}\u{1F3FE}','\u{1F932}\u{1F3FF}','\u{1F933}\u{1F3FB}','\u{1F933}\u{1F3FC}','\u{1F933}\u{1F3FD}','\u{1F933}\u{1F3FE}','\u{1F933}\u{1F3FF}','\u{1F934}\u{1F3FB}','\u{1F934}\u{1F3FC}','\u{1F934}\u{1F3FD}','\u{1F934}\u{1F3FE}','\u{1F934}\u{1F3FF}','\u{1F935}\u200D\u2640\uFE0F','\u{1F935}\u200D\u2642\uFE0F','\u{1F935}\u{1F3FB}','\u{1F935}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F935}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F935}\u{1F3FC}','\u{1F935}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F935}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F935}\u{1F3FD}','\u{1F935}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F935}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F935}\u{1F3FE}','\u{1F935}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F935}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F935}\u{1F3FF}','\u{1F935}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F935}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F936}\u{1F3FB}','\u{1F936}\u{1F3FC}','\u{1F936}\u{1F3FD}','\u{1F936}\u{1F3FE}','\u{1F936}\u{1F3FF}','\u{1F937}\u200D\u2640\uFE0F','\u{1F937}\u200D\u2642\uFE0F','\u{1F937}\u{1F3FB}','\u{1F937}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F937}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F937}\u{1F3FC}','\u{1F937}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F937}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F937}\u{1F3FD}','\u{1F937}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F937}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F937}\u{1F3FE}','\u{1F937}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F937}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F937}\u{1F3FF}','\u{1F937}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F937}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F938}\u200D\u2640\uFE0F','\u{1F938}\u200D\u2642\uFE0F','\u{1F938}\u{1F3FB}','\u{1F938}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F938}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F938}\u{1F3FC}','\u{1F938}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F938}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F938}\u{1F3FD}','\u{1F938}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F938}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F938}\u{1F3FE}','\u{1F938}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F938}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F938}\u{1F3FF}','\u{1F938}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F938}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F939}\u200D\u2640\uFE0F','\u{1F939}\u200D\u2642\uFE0F','\u{1F939}\u{1F3FB}','\u{1F939}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F939}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F939}\u{1F3FC}','\u{1F939}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F939}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F939}\u{1F3FD}','\u{1F939}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F939}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F939}\u{1F3FE}','\u{1F939}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F939}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F939}\u{1F3FF}','\u{1F939}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F939}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F93C}\u200D\u2640\uFE0F','\u{1F93C}\u200D\u2642\uFE0F','\u{1F93C}\u{1F3FB}','\u{1F93C}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F93C}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F93C}\u{1F3FC}','\u{1F93C}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F93C}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F93C}\u{1F3FD}','\u{1F93C}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F93C}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F93C}\u{1F3FE}','\u{1F93C}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F93C}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F93C}\u{1F3FF}','\u{1F93C}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F93C}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F93D}\u200D\u2640\uFE0F','\u{1F93D}\u200D\u2642\uFE0F','\u{1F93D}\u{1F3FB}','\u{1F93D}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F93D}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F93D}\u{1F3FC}','\u{1F93D}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F93D}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F93D}\u{1F3FD}','\u{1F93D}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F93D}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F93D}\u{1F3FE}','\u{1F93D}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F93D}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F93D}\u{1F3FF}','\u{1F93D}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F93D}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F93E}\u200D\u2640\uFE0F','\u{1F93E}\u200D\u2642\uFE0F','\u{1F93E}\u{1F3FB}','\u{1F93E}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F93E}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F93E}\u{1F3FC}','\u{1F93E}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F93E}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F93E}\u{1F3FD}','\u{1F93E}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F93E}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F93E}\u{1F3FE}','\u{1F93E}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F93E}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F93E}\u{1F3FF}','\u{1F93E}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F93E}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F977}\u{1F3FB}','\u{1F977}\u{1F3FC}','\u{1F977}\u{1F3FD}','\u{1F977}\u{1F3FE}','\u{1F977}\u{1F3FF}','\u{1F9B5}\u{1F3FB}','\u{1F9B5}\u{1F3FC}','\u{1F9B5}\u{1F3FD}','\u{1F9B5}\u{1F3FE}','\u{1F9B5}\u{1F3FF}','\u{1F9B6}\u{1F3FB}','\u{1F9B6}\u{1F3FC}','\u{1F9B6}\u{1F3FD}','\u{1F9B6}\u{1F3FE}','\u{1F9B6}\u{1F3FF}','\u{1F9B8}\u200D\u2640\uFE0F','\u{1F9B8}\u200D\u2642\uFE0F','\u{1F9B8}\u{1F3FB}','\u{1F9B8}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9B8}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9B8}\u{1F3FC}','\u{1F9B8}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9B8}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9B8}\u{1F3FD}','\u{1F9B8}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9B8}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9B8}\u{1F3FE}','\u{1F9B8}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9B8}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9B8}\u{1F3FF}','\u{1F9B8}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9B8}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9B9}\u200D\u2640\uFE0F','\u{1F9B9}\u200D\u2642\uFE0F','\u{1F9B9}\u{1F3FB}','\u{1F9B9}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9B9}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9B9}\u{1F3FC}','\u{1F9B9}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9B9}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9B9}\u{1F3FD}','\u{1F9B9}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9B9}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9B9}\u{1F3FE}','\u{1F9B9}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9B9}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9B9}\u{1F3FF}','\u{1F9B9}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9B9}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9BB}\u{1F3FB}','\u{1F9BB}\u{1F3FC}','\u{1F9BB}\u{1F3FD}','\u{1F9BB}\u{1F3FE}','\u{1F9BB}\u{1F3FF}','\u{1F9CD}\u200D\u2640\uFE0F','\u{1F9CD}\u200D\u2642\uFE0F','\u{1F9CD}\u{1F3FB}','\u{1F9CD}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9CD}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9CD}\u{1F3FC}','\u{1F9CD}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9CD}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9CD}\u{1F3FD}','\u{1F9CD}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9CD}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9CD}\u{1F3FE}','\u{1F9CD}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9CD}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9CD}\u{1F3FF}','\u{1F9CD}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9CD}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9CE}\u200D\u2640\uFE0F','\u{1F9CE}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u200D\u2642\uFE0F','\u{1F9CE}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FB}','\u{1F9CE}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9CE}\u{1F3FB}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9CE}\u{1F3FB}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FB}\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FC}','\u{1F9CE}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9CE}\u{1F3FC}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9CE}\u{1F3FC}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FC}\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FD}','\u{1F9CE}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9CE}\u{1F3FD}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9CE}\u{1F3FD}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FD}\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FE}','\u{1F9CE}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9CE}\u{1F3FE}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9CE}\u{1F3FE}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FE}\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FF}','\u{1F9CE}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9CE}\u{1F3FF}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9CE}\u{1F3FF}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FF}\u200D\u27A1\uFE0F','\u{1F9CF}\u200D\u2640\uFE0F','\u{1F9CF}\u200D\u2642\uFE0F','\u{1F9CF}\u{1F3FB}','\u{1F9CF}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9CF}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9CF}\u{1F3FC}','\u{1F9CF}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9CF}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9CF}\u{1F3FD}','\u{1F9CF}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9CF}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9CF}\u{1F3FE}','\u{1F9CF}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9CF}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9CF}\u{1F3FF}','\u{1F9CF}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9CF}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9D1}\u200D\u2695\uFE0F','\u{1F9D1}\u200D\u2696\uFE0F','\u{1F9D1}\u200D\u2708\uFE0F','\u{1F9D1}\u200D\u{1F33E}','\u{1F9D1}\u200D\u{1F373}','\u{1F9D1}\u200D\u{1F37C}','\u{1F9D1}\u200D\u{1F384}','\u{1F9D1}\u200D\u{1F393}','\u{1F9D1}\u200D\u{1F3A4}','\u{1F9D1}\u200D\u{1F3A8}','\u{1F9D1}\u200D\u{1F3EB}','\u{1F9D1}\u200D\u{1F3ED}','\u{1F9D1}\u200D\u{1F4BB}','\u{1F9D1}\u200D\u{1F4BC}','\u{1F9D1}\u200D\u{1F527}','\u{1F9D1}\u200D\u{1F52C}','\u{1F9D1}\u200D\u{1F680}','\u{1F9D1}\u200D\u{1F692}','\u{1F9D1}\u200D\u{1F91D}\u200D\u{1F9D1}','\u{1F9D1}\u200D\u{1F9AF}','\u{1F9D1}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F9D1}\u200D\u{1F9B0}','\u{1F9D1}\u200D\u{1F9B1}','\u{1F9D1}\u200D\u{1F9B2}','\u{1F9D1}\u200D\u{1F9B3}','\u{1F9D1}\u200D\u{1F9BC}','\u{1F9D1}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F9D1}\u200D\u{1F9BD}','\u{1F9D1}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F9D1}\u200D\u{1F9D1}\u200D\u{1F9D2}','\u{1F9D1}\u200D\u{1F9D1}\u200D\u{1F9D2}\u200D\u{1F9D2}','\u{1F9D1}\u200D\u{1F9D2}','\u{1F9D1}\u200D\u{1F9D2}\u200D\u{1F9D2}','\u{1F9D1}\u200D\u{1FA70}','\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FB}\u200D\u2695\uFE0F','\u{1F9D1}\u{1F3FB}\u200D\u2696\uFE0F','\u{1F9D1}\u{1F3FB}\u200D\u2708\uFE0F','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FB}\u200D\u{1F33E}','\u{1F9D1}\u{1F3FB}\u200D\u{1F373}','\u{1F9D1}\u{1F3FB}\u200D\u{1F37C}','\u{1F9D1}\u{1F3FB}\u200D\u{1F384}','\u{1F9D1}\u{1F3FB}\u200D\u{1F393}','\u{1F9D1}\u{1F3FB}\u200D\u{1F3A4}','\u{1F9D1}\u{1F3FB}\u200D\u{1F3A8}','\u{1F9D1}\u{1F3FB}\u200D\u{1F3EB}','\u{1F9D1}\u{1F3FB}\u200D\u{1F3ED}','\u{1F9D1}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FB}\u200D\u{1F4BB}','\u{1F9D1}\u{1F3FB}\u200D\u{1F4BC}','\u{1F9D1}\u{1F3FB}\u200D\u{1F527}','\u{1F9D1}\u{1F3FB}\u200D\u{1F52C}','\u{1F9D1}\u{1F3FB}\u200D\u{1F680}','\u{1F9D1}\u{1F3FB}\u200D\u{1F692}','\u{1F9D1}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9AF}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FB}\u200D\u{1F9B0}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9B1}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9B2}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9B3}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9BC}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FB}\u200D\u{1F9BD}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FB}\u200D\u{1FA70}','\u{1F9D1}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FC}\u200D\u2695\uFE0F','\u{1F9D1}\u{1F3FC}\u200D\u2696\uFE0F','\u{1F9D1}\u{1F3FC}\u200D\u2708\uFE0F','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FC}\u200D\u{1F33E}','\u{1F9D1}\u{1F3FC}\u200D\u{1F373}','\u{1F9D1}\u{1F3FC}\u200D\u{1F37C}','\u{1F9D1}\u{1F3FC}\u200D\u{1F384}','\u{1F9D1}\u{1F3FC}\u200D\u{1F393}','\u{1F9D1}\u{1F3FC}\u200D\u{1F3A4}','\u{1F9D1}\u{1F3FC}\u200D\u{1F3A8}','\u{1F9D1}\u{1F3FC}\u200D\u{1F3EB}','\u{1F9D1}\u{1F3FC}\u200D\u{1F3ED}','\u{1F9D1}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FC}\u200D\u{1F4BB}','\u{1F9D1}\u{1F3FC}\u200D\u{1F4BC}','\u{1F9D1}\u{1F3FC}\u200D\u{1F527}','\u{1F9D1}\u{1F3FC}\u200D\u{1F52C}','\u{1F9D1}\u{1F3FC}\u200D\u{1F680}','\u{1F9D1}\u{1F3FC}\u200D\u{1F692}','\u{1F9D1}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9AF}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FC}\u200D\u{1F9B0}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9B1}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9B2}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9B3}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9BC}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FC}\u200D\u{1F9BD}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FC}\u200D\u{1FA70}','\u{1F9D1}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FD}\u200D\u2695\uFE0F','\u{1F9D1}\u{1F3FD}\u200D\u2696\uFE0F','\u{1F9D1}\u{1F3FD}\u200D\u2708\uFE0F','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FD}\u200D\u{1F33E}','\u{1F9D1}\u{1F3FD}\u200D\u{1F373}','\u{1F9D1}\u{1F3FD}\u200D\u{1F37C}','\u{1F9D1}\u{1F3FD}\u200D\u{1F384}','\u{1F9D1}\u{1F3FD}\u200D\u{1F393}','\u{1F9D1}\u{1F3FD}\u200D\u{1F3A4}','\u{1F9D1}\u{1F3FD}\u200D\u{1F3A8}','\u{1F9D1}\u{1F3FD}\u200D\u{1F3EB}','\u{1F9D1}\u{1F3FD}\u200D\u{1F3ED}','\u{1F9D1}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FD}\u200D\u{1F4BB}','\u{1F9D1}\u{1F3FD}\u200D\u{1F4BC}','\u{1F9D1}\u{1F3FD}\u200D\u{1F527}','\u{1F9D1}\u{1F3FD}\u200D\u{1F52C}','\u{1F9D1}\u{1F3FD}\u200D\u{1F680}','\u{1F9D1}\u{1F3FD}\u200D\u{1F692}','\u{1F9D1}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9AF}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FD}\u200D\u{1F9B0}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9B1}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9B2}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9B3}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9BC}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FD}\u200D\u{1F9BD}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FD}\u200D\u{1FA70}','\u{1F9D1}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FE}\u200D\u2695\uFE0F','\u{1F9D1}\u{1F3FE}\u200D\u2696\uFE0F','\u{1F9D1}\u{1F3FE}\u200D\u2708\uFE0F','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FE}\u200D\u{1F33E}','\u{1F9D1}\u{1F3FE}\u200D\u{1F373}','\u{1F9D1}\u{1F3FE}\u200D\u{1F37C}','\u{1F9D1}\u{1F3FE}\u200D\u{1F384}','\u{1F9D1}\u{1F3FE}\u200D\u{1F393}','\u{1F9D1}\u{1F3FE}\u200D\u{1F3A4}','\u{1F9D1}\u{1F3FE}\u200D\u{1F3A8}','\u{1F9D1}\u{1F3FE}\u200D\u{1F3EB}','\u{1F9D1}\u{1F3FE}\u200D\u{1F3ED}','\u{1F9D1}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FE}\u200D\u{1F4BB}','\u{1F9D1}\u{1F3FE}\u200D\u{1F4BC}','\u{1F9D1}\u{1F3FE}\u200D\u{1F527}','\u{1F9D1}\u{1F3FE}\u200D\u{1F52C}','\u{1F9D1}\u{1F3FE}\u200D\u{1F680}','\u{1F9D1}\u{1F3FE}\u200D\u{1F692}','\u{1F9D1}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9AF}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FE}\u200D\u{1F9B0}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9B1}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9B2}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9B3}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9BC}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FE}\u200D\u{1F9BD}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FE}\u200D\u{1FA70}','\u{1F9D1}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FF}\u200D\u2695\uFE0F','\u{1F9D1}\u{1F3FF}\u200D\u2696\uFE0F','\u{1F9D1}\u{1F3FF}\u200D\u2708\uFE0F','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FF}\u200D\u{1F33E}','\u{1F9D1}\u{1F3FF}\u200D\u{1F373}','\u{1F9D1}\u{1F3FF}\u200D\u{1F37C}','\u{1F9D1}\u{1F3FF}\u200D\u{1F384}','\u{1F9D1}\u{1F3FF}\u200D\u{1F393}','\u{1F9D1}\u{1F3FF}\u200D\u{1F3A4}','\u{1F9D1}\u{1F3FF}\u200D\u{1F3A8}','\u{1F9D1}\u{1F3FF}\u200D\u{1F3EB}','\u{1F9D1}\u{1F3FF}\u200D\u{1F3ED}','\u{1F9D1}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FF}\u200D\u{1F4BB}','\u{1F9D1}\u{1F3FF}\u200D\u{1F4BC}','\u{1F9D1}\u{1F3FF}\u200D\u{1F527}','\u{1F9D1}\u{1F3FF}\u200D\u{1F52C}','\u{1F9D1}\u{1F3FF}\u200D\u{1F680}','\u{1F9D1}\u{1F3FF}\u200D\u{1F692}','\u{1F9D1}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9AF}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FF}\u200D\u{1F9B0}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9B1}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9B2}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9B3}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9BC}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FF}\u200D\u{1F9BD}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FF}\u200D\u{1FA70}','\u{1F9D1}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D2}\u{1F3FB}','\u{1F9D2}\u{1F3FC}','\u{1F9D2}\u{1F3FD}','\u{1F9D2}\u{1F3FE}','\u{1F9D2}\u{1F3FF}','\u{1F9D3}\u{1F3FB}','\u{1F9D3}\u{1F3FC}','\u{1F9D3}\u{1F3FD}','\u{1F9D3}\u{1F3FE}','\u{1F9D3}\u{1F3FF}','\u{1F9D4}\u200D\u2640\uFE0F','\u{1F9D4}\u200D\u2642\uFE0F','\u{1F9D4}\u{1F3FB}','\u{1F9D4}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9D4}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9D4}\u{1F3FC}','\u{1F9D4}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9D4}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9D4}\u{1F3FD}','\u{1F9D4}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9D4}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9D4}\u{1F3FE}','\u{1F9D4}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9D4}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9D4}\u{1F3FF}','\u{1F9D4}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9D4}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9D5}\u{1F3FB}','\u{1F9D5}\u{1F3FC}','\u{1F9D5}\u{1F3FD}','\u{1F9D5}\u{1F3FE}','\u{1F9D5}\u{1F3FF}','\u{1F9D6}\u200D\u2640\uFE0F','\u{1F9D6}\u200D\u2642\uFE0F','\u{1F9D6}\u{1F3FB}','\u{1F9D6}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9D6}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9D6}\u{1F3FC}','\u{1F9D6}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9D6}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9D6}\u{1F3FD}','\u{1F9D6}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9D6}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9D6}\u{1F3FE}','\u{1F9D6}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9D6}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9D6}\u{1F3FF}','\u{1F9D6}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9D6}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9D7}\u200D\u2640\uFE0F','\u{1F9D7}\u200D\u2642\uFE0F','\u{1F9D7}\u{1F3FB}','\u{1F9D7}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9D7}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9D7}\u{1F3FC}','\u{1F9D7}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9D7}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9D7}\u{1F3FD}','\u{1F9D7}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9D7}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9D7}\u{1F3FE}','\u{1F9D7}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9D7}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9D7}\u{1F3FF}','\u{1F9D7}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9D7}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9D8}\u200D\u2640\uFE0F','\u{1F9D8}\u200D\u2642\uFE0F','\u{1F9D8}\u{1F3FB}','\u{1F9D8}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9D8}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9D8}\u{1F3FC}','\u{1F9D8}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9D8}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9D8}\u{1F3FD}','\u{1F9D8}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9D8}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9D8}\u{1F3FE}','\u{1F9D8}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9D8}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9D8}\u{1F3FF}','\u{1F9D8}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9D8}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9D9}\u200D\u2640\uFE0F','\u{1F9D9}\u200D\u2642\uFE0F','\u{1F9D9}\u{1F3FB}','\u{1F9D9}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9D9}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9D9}\u{1F3FC}','\u{1F9D9}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9D9}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9D9}\u{1F3FD}','\u{1F9D9}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9D9}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9D9}\u{1F3FE}','\u{1F9D9}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9D9}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9D9}\u{1F3FF}','\u{1F9D9}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9D9}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9DA}\u200D\u2640\uFE0F','\u{1F9DA}\u200D\u2642\uFE0F','\u{1F9DA}\u{1F3FB}','\u{1F9DA}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9DA}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9DA}\u{1F3FC}','\u{1F9DA}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9DA}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9DA}\u{1F3FD}','\u{1F9DA}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9DA}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9DA}\u{1F3FE}','\u{1F9DA}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9DA}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9DA}\u{1F3FF}','\u{1F9DA}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9DA}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9DB}\u200D\u2640\uFE0F','\u{1F9DB}\u200D\u2642\uFE0F','\u{1F9DB}\u{1F3FB}','\u{1F9DB}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9DB}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9DB}\u{1F3FC}','\u{1F9DB}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9DB}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9DB}\u{1F3FD}','\u{1F9DB}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9DB}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9DB}\u{1F3FE}','\u{1F9DB}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9DB}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9DB}\u{1F3FF}','\u{1F9DB}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9DB}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9DC}\u200D\u2640\uFE0F','\u{1F9DC}\u200D\u2642\uFE0F','\u{1F9DC}\u{1F3FB}','\u{1F9DC}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9DC}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9DC}\u{1F3FC}','\u{1F9DC}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9DC}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9DC}\u{1F3FD}','\u{1F9DC}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9DC}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9DC}\u{1F3FE}','\u{1F9DC}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9DC}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9DC}\u{1F3FF}','\u{1F9DC}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9DC}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9DD}\u200D\u2640\uFE0F','\u{1F9DD}\u200D\u2642\uFE0F','\u{1F9DD}\u{1F3FB}','\u{1F9DD}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9DD}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9DD}\u{1F3FC}','\u{1F9DD}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9DD}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9DD}\u{1F3FD}','\u{1F9DD}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9DD}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9DD}\u{1F3FE}','\u{1F9DD}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9DD}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9DD}\u{1F3FF}','\u{1F9DD}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9DD}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9DE}\u200D\u2640\uFE0F','\u{1F9DE}\u200D\u2642\uFE0F','\u{1F9DF}\u200D\u2640\uFE0F','\u{1F9DF}\u200D\u2642\uFE0F','\u{1FAC3}\u{1F3FB}','\u{1FAC3}\u{1F3FC}','\u{1FAC3}\u{1F3FD}','\u{1FAC3}\u{1F3FE}','\u{1FAC3}\u{1F3FF}','\u{1FAC4}\u{1F3FB}','\u{1FAC4}\u{1F3FC}','\u{1FAC4}\u{1F3FD}','\u{1FAC4}\u{1F3FE}','\u{1FAC4}\u{1F3FF}','\u{1FAC5}\u{1F3FB}','\u{1FAC5}\u{1F3FC}','\u{1FAC5}\u{1F3FD}','\u{1FAC5}\u{1F3FE}','\u{1FAC5}\u{1F3FF}','\u{1FAF0}\u{1F3FB}','\u{1FAF0}\u{1F3FC}','\u{1FAF0}\u{1F3FD}','\u{1FAF0}\u{1F3FE}','\u{1FAF0}\u{1F3FF}','\u{1FAF1}\u{1F3FB}','\u{1FAF1}\u{1F3FB}\u200D\u{1FAF2}\u{1F3FC}','\u{1FAF1}\u{1F3FB}\u200D\u{1FAF2}\u{1F3FD}','\u{1FAF1}\u{1F3FB}\u200D\u{1FAF2}\u{1F3FE}','\u{1FAF1}\u{1F3FB}\u200D\u{1FAF2}\u{1F3FF}','\u{1FAF1}\u{1F3FC}','\u{1FAF1}\u{1F3FC}\u200D\u{1FAF2}\u{1F3FB}','\u{1FAF1}\u{1F3FC}\u200D\u{1FAF2}\u{1F3FD}','\u{1FAF1}\u{1F3FC}\u200D\u{1FAF2}\u{1F3FE}','\u{1FAF1}\u{1F3FC}\u200D\u{1FAF2}\u{1F3FF}','\u{1FAF1}\u{1F3FD}','\u{1FAF1}\u{1F3FD}\u200D\u{1FAF2}\u{1F3FB}','\u{1FAF1}\u{1F3FD}\u200D\u{1FAF2}\u{1F3FC}','\u{1FAF1}\u{1F3FD}\u200D\u{1FAF2}\u{1F3FE}','\u{1FAF1}\u{1F3FD}\u200D\u{1FAF2}\u{1F3FF}','\u{1FAF1}\u{1F3FE}','\u{1FAF1}\u{1F3FE}\u200D\u{1FAF2}\u{1F3FB}','\u{1FAF1}\u{1F3FE}\u200D\u{1FAF2}\u{1F3FC}','\u{1FAF1}\u{1F3FE}\u200D\u{1FAF2}\u{1F3FD}','\u{1FAF1}\u{1F3FE}\u200D\u{1FAF2}\u{1F3FF}','\u{1FAF1}\u{1F3FF}','\u{1FAF1}\u{1F3FF}\u200D\u{1FAF2}\u{1F3FB}','\u{1FAF1}\u{1F3FF}\u200D\u{1FAF2}\u{1F3FC}','\u{1FAF1}\u{1F3FF}\u200D\u{1FAF2}\u{1F3FD}','\u{1FAF1}\u{1F3FF}\u200D\u{1FAF2}\u{1F3FE}','\u{1FAF2}\u{1F3FB}','\u{1FAF2}\u{1F3FC}','\u{1FAF2}\u{1F3FD}','\u{1FAF2}\u{1F3FE}','\u{1FAF2}\u{1F3FF}','\u{1FAF3}\u{1F3FB}','\u{1FAF3}\u{1F3FC}','\u{1FAF3}\u{1F3FD}','\u{1FAF3}\u{1F3FE}','\u{1FAF3}\u{1F3FF}','\u{1FAF4}\u{1F3FB}','\u{1FAF4}\u{1F3FC}','\u{1FAF4}\u{1F3FD}','\u{1FAF4}\u{1F3FE}','\u{1FAF4}\u{1F3FF}','\u{1FAF5}\u{1F3FB}','\u{1FAF5}\u{1F3FC}','\u{1FAF5}\u{1F3FD}','\u{1FAF5}\u{1F3FE}','\u{1FAF5}\u{1F3FF}','\u{1FAF6}\u{1F3FB}','\u{1FAF6}\u{1F3FC}','\u{1FAF6}\u{1F3FD}','\u{1FAF6}\u{1F3FE}','\u{1FAF6}\u{1F3FF}','\u{1FAF7}\u{1F3FB}','\u{1FAF7}\u{1F3FC}','\u{1FAF7}\u{1F3FD}','\u{1FAF7}\u{1F3FE}','\u{1FAF7}\u{1F3FF}','\u{1FAF8}\u{1F3FB}','\u{1FAF8}\u{1F3FC}','\u{1FAF8}\u{1F3FD}','\u{1FAF8}\u{1F3FE}','\u{1FAF8}\u{1F3FF}']; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_Flag_Sequence.js b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_Flag_Sequence.js new file mode 100644 index 0000000000000000000000000000000000000000..6960e10f7bcbf42b2efa7636e803de546d1e3025 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_Flag_Sequence.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(); + +exports.characters = set; +exports.strings = ['\u{1F1E6}\u{1F1E8}','\u{1F1E6}\u{1F1E9}','\u{1F1E6}\u{1F1EA}','\u{1F1E6}\u{1F1EB}','\u{1F1E6}\u{1F1EC}','\u{1F1E6}\u{1F1EE}','\u{1F1E6}\u{1F1F1}','\u{1F1E6}\u{1F1F2}','\u{1F1E6}\u{1F1F4}','\u{1F1E6}\u{1F1F6}','\u{1F1E6}\u{1F1F7}','\u{1F1E6}\u{1F1F8}','\u{1F1E6}\u{1F1F9}','\u{1F1E6}\u{1F1FA}','\u{1F1E6}\u{1F1FC}','\u{1F1E6}\u{1F1FD}','\u{1F1E6}\u{1F1FF}','\u{1F1E7}\u{1F1E6}','\u{1F1E7}\u{1F1E7}','\u{1F1E7}\u{1F1E9}','\u{1F1E7}\u{1F1EA}','\u{1F1E7}\u{1F1EB}','\u{1F1E7}\u{1F1EC}','\u{1F1E7}\u{1F1ED}','\u{1F1E7}\u{1F1EE}','\u{1F1E7}\u{1F1EF}','\u{1F1E7}\u{1F1F1}','\u{1F1E7}\u{1F1F2}','\u{1F1E7}\u{1F1F3}','\u{1F1E7}\u{1F1F4}','\u{1F1E7}\u{1F1F6}','\u{1F1E7}\u{1F1F7}','\u{1F1E7}\u{1F1F8}','\u{1F1E7}\u{1F1F9}','\u{1F1E7}\u{1F1FB}','\u{1F1E7}\u{1F1FC}','\u{1F1E7}\u{1F1FE}','\u{1F1E7}\u{1F1FF}','\u{1F1E8}\u{1F1E6}','\u{1F1E8}\u{1F1E8}','\u{1F1E8}\u{1F1E9}','\u{1F1E8}\u{1F1EB}','\u{1F1E8}\u{1F1EC}','\u{1F1E8}\u{1F1ED}','\u{1F1E8}\u{1F1EE}','\u{1F1E8}\u{1F1F0}','\u{1F1E8}\u{1F1F1}','\u{1F1E8}\u{1F1F2}','\u{1F1E8}\u{1F1F3}','\u{1F1E8}\u{1F1F4}','\u{1F1E8}\u{1F1F5}','\u{1F1E8}\u{1F1F6}','\u{1F1E8}\u{1F1F7}','\u{1F1E8}\u{1F1FA}','\u{1F1E8}\u{1F1FB}','\u{1F1E8}\u{1F1FC}','\u{1F1E8}\u{1F1FD}','\u{1F1E8}\u{1F1FE}','\u{1F1E8}\u{1F1FF}','\u{1F1E9}\u{1F1EA}','\u{1F1E9}\u{1F1EC}','\u{1F1E9}\u{1F1EF}','\u{1F1E9}\u{1F1F0}','\u{1F1E9}\u{1F1F2}','\u{1F1E9}\u{1F1F4}','\u{1F1E9}\u{1F1FF}','\u{1F1EA}\u{1F1E6}','\u{1F1EA}\u{1F1E8}','\u{1F1EA}\u{1F1EA}','\u{1F1EA}\u{1F1EC}','\u{1F1EA}\u{1F1ED}','\u{1F1EA}\u{1F1F7}','\u{1F1EA}\u{1F1F8}','\u{1F1EA}\u{1F1F9}','\u{1F1EA}\u{1F1FA}','\u{1F1EB}\u{1F1EE}','\u{1F1EB}\u{1F1EF}','\u{1F1EB}\u{1F1F0}','\u{1F1EB}\u{1F1F2}','\u{1F1EB}\u{1F1F4}','\u{1F1EB}\u{1F1F7}','\u{1F1EC}\u{1F1E6}','\u{1F1EC}\u{1F1E7}','\u{1F1EC}\u{1F1E9}','\u{1F1EC}\u{1F1EA}','\u{1F1EC}\u{1F1EB}','\u{1F1EC}\u{1F1EC}','\u{1F1EC}\u{1F1ED}','\u{1F1EC}\u{1F1EE}','\u{1F1EC}\u{1F1F1}','\u{1F1EC}\u{1F1F2}','\u{1F1EC}\u{1F1F3}','\u{1F1EC}\u{1F1F5}','\u{1F1EC}\u{1F1F6}','\u{1F1EC}\u{1F1F7}','\u{1F1EC}\u{1F1F8}','\u{1F1EC}\u{1F1F9}','\u{1F1EC}\u{1F1FA}','\u{1F1EC}\u{1F1FC}','\u{1F1EC}\u{1F1FE}','\u{1F1ED}\u{1F1F0}','\u{1F1ED}\u{1F1F2}','\u{1F1ED}\u{1F1F3}','\u{1F1ED}\u{1F1F7}','\u{1F1ED}\u{1F1F9}','\u{1F1ED}\u{1F1FA}','\u{1F1EE}\u{1F1E8}','\u{1F1EE}\u{1F1E9}','\u{1F1EE}\u{1F1EA}','\u{1F1EE}\u{1F1F1}','\u{1F1EE}\u{1F1F2}','\u{1F1EE}\u{1F1F3}','\u{1F1EE}\u{1F1F4}','\u{1F1EE}\u{1F1F6}','\u{1F1EE}\u{1F1F7}','\u{1F1EE}\u{1F1F8}','\u{1F1EE}\u{1F1F9}','\u{1F1EF}\u{1F1EA}','\u{1F1EF}\u{1F1F2}','\u{1F1EF}\u{1F1F4}','\u{1F1EF}\u{1F1F5}','\u{1F1F0}\u{1F1EA}','\u{1F1F0}\u{1F1EC}','\u{1F1F0}\u{1F1ED}','\u{1F1F0}\u{1F1EE}','\u{1F1F0}\u{1F1F2}','\u{1F1F0}\u{1F1F3}','\u{1F1F0}\u{1F1F5}','\u{1F1F0}\u{1F1F7}','\u{1F1F0}\u{1F1FC}','\u{1F1F0}\u{1F1FE}','\u{1F1F0}\u{1F1FF}','\u{1F1F1}\u{1F1E6}','\u{1F1F1}\u{1F1E7}','\u{1F1F1}\u{1F1E8}','\u{1F1F1}\u{1F1EE}','\u{1F1F1}\u{1F1F0}','\u{1F1F1}\u{1F1F7}','\u{1F1F1}\u{1F1F8}','\u{1F1F1}\u{1F1F9}','\u{1F1F1}\u{1F1FA}','\u{1F1F1}\u{1F1FB}','\u{1F1F1}\u{1F1FE}','\u{1F1F2}\u{1F1E6}','\u{1F1F2}\u{1F1E8}','\u{1F1F2}\u{1F1E9}','\u{1F1F2}\u{1F1EA}','\u{1F1F2}\u{1F1EB}','\u{1F1F2}\u{1F1EC}','\u{1F1F2}\u{1F1ED}','\u{1F1F2}\u{1F1F0}','\u{1F1F2}\u{1F1F1}','\u{1F1F2}\u{1F1F2}','\u{1F1F2}\u{1F1F3}','\u{1F1F2}\u{1F1F4}','\u{1F1F2}\u{1F1F5}','\u{1F1F2}\u{1F1F6}','\u{1F1F2}\u{1F1F7}','\u{1F1F2}\u{1F1F8}','\u{1F1F2}\u{1F1F9}','\u{1F1F2}\u{1F1FA}','\u{1F1F2}\u{1F1FB}','\u{1F1F2}\u{1F1FC}','\u{1F1F2}\u{1F1FD}','\u{1F1F2}\u{1F1FE}','\u{1F1F2}\u{1F1FF}','\u{1F1F3}\u{1F1E6}','\u{1F1F3}\u{1F1E8}','\u{1F1F3}\u{1F1EA}','\u{1F1F3}\u{1F1EB}','\u{1F1F3}\u{1F1EC}','\u{1F1F3}\u{1F1EE}','\u{1F1F3}\u{1F1F1}','\u{1F1F3}\u{1F1F4}','\u{1F1F3}\u{1F1F5}','\u{1F1F3}\u{1F1F7}','\u{1F1F3}\u{1F1FA}','\u{1F1F3}\u{1F1FF}','\u{1F1F4}\u{1F1F2}','\u{1F1F5}\u{1F1E6}','\u{1F1F5}\u{1F1EA}','\u{1F1F5}\u{1F1EB}','\u{1F1F5}\u{1F1EC}','\u{1F1F5}\u{1F1ED}','\u{1F1F5}\u{1F1F0}','\u{1F1F5}\u{1F1F1}','\u{1F1F5}\u{1F1F2}','\u{1F1F5}\u{1F1F3}','\u{1F1F5}\u{1F1F7}','\u{1F1F5}\u{1F1F8}','\u{1F1F5}\u{1F1F9}','\u{1F1F5}\u{1F1FC}','\u{1F1F5}\u{1F1FE}','\u{1F1F6}\u{1F1E6}','\u{1F1F7}\u{1F1EA}','\u{1F1F7}\u{1F1F4}','\u{1F1F7}\u{1F1F8}','\u{1F1F7}\u{1F1FA}','\u{1F1F7}\u{1F1FC}','\u{1F1F8}\u{1F1E6}','\u{1F1F8}\u{1F1E7}','\u{1F1F8}\u{1F1E8}','\u{1F1F8}\u{1F1E9}','\u{1F1F8}\u{1F1EA}','\u{1F1F8}\u{1F1EC}','\u{1F1F8}\u{1F1ED}','\u{1F1F8}\u{1F1EE}','\u{1F1F8}\u{1F1EF}','\u{1F1F8}\u{1F1F0}','\u{1F1F8}\u{1F1F1}','\u{1F1F8}\u{1F1F2}','\u{1F1F8}\u{1F1F3}','\u{1F1F8}\u{1F1F4}','\u{1F1F8}\u{1F1F7}','\u{1F1F8}\u{1F1F8}','\u{1F1F8}\u{1F1F9}','\u{1F1F8}\u{1F1FB}','\u{1F1F8}\u{1F1FD}','\u{1F1F8}\u{1F1FE}','\u{1F1F8}\u{1F1FF}','\u{1F1F9}\u{1F1E6}','\u{1F1F9}\u{1F1E8}','\u{1F1F9}\u{1F1E9}','\u{1F1F9}\u{1F1EB}','\u{1F1F9}\u{1F1EC}','\u{1F1F9}\u{1F1ED}','\u{1F1F9}\u{1F1EF}','\u{1F1F9}\u{1F1F0}','\u{1F1F9}\u{1F1F1}','\u{1F1F9}\u{1F1F2}','\u{1F1F9}\u{1F1F3}','\u{1F1F9}\u{1F1F4}','\u{1F1F9}\u{1F1F7}','\u{1F1F9}\u{1F1F9}','\u{1F1F9}\u{1F1FB}','\u{1F1F9}\u{1F1FC}','\u{1F1F9}\u{1F1FF}','\u{1F1FA}\u{1F1E6}','\u{1F1FA}\u{1F1EC}','\u{1F1FA}\u{1F1F2}','\u{1F1FA}\u{1F1F3}','\u{1F1FA}\u{1F1F8}','\u{1F1FA}\u{1F1FE}','\u{1F1FA}\u{1F1FF}','\u{1F1FB}\u{1F1E6}','\u{1F1FB}\u{1F1E8}','\u{1F1FB}\u{1F1EA}','\u{1F1FB}\u{1F1EC}','\u{1F1FB}\u{1F1EE}','\u{1F1FB}\u{1F1F3}','\u{1F1FB}\u{1F1FA}','\u{1F1FC}\u{1F1EB}','\u{1F1FC}\u{1F1F8}','\u{1F1FD}\u{1F1F0}','\u{1F1FE}\u{1F1EA}','\u{1F1FE}\u{1F1F9}','\u{1F1FF}\u{1F1E6}','\u{1F1FF}\u{1F1F2}','\u{1F1FF}\u{1F1FC}']; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_Modifier_Sequence.js b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_Modifier_Sequence.js new file mode 100644 index 0000000000000000000000000000000000000000..3c418ecba8f76d8768874e9d2e00444aeea28a73 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_Modifier_Sequence.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(); + +exports.characters = set; +exports.strings = ['\u261D\u{1F3FB}','\u261D\u{1F3FC}','\u261D\u{1F3FD}','\u261D\u{1F3FE}','\u261D\u{1F3FF}','\u26F9\u{1F3FB}','\u26F9\u{1F3FC}','\u26F9\u{1F3FD}','\u26F9\u{1F3FE}','\u26F9\u{1F3FF}','\u270A\u{1F3FB}','\u270A\u{1F3FC}','\u270A\u{1F3FD}','\u270A\u{1F3FE}','\u270A\u{1F3FF}','\u270B\u{1F3FB}','\u270B\u{1F3FC}','\u270B\u{1F3FD}','\u270B\u{1F3FE}','\u270B\u{1F3FF}','\u270C\u{1F3FB}','\u270C\u{1F3FC}','\u270C\u{1F3FD}','\u270C\u{1F3FE}','\u270C\u{1F3FF}','\u270D\u{1F3FB}','\u270D\u{1F3FC}','\u270D\u{1F3FD}','\u270D\u{1F3FE}','\u270D\u{1F3FF}','\u{1F385}\u{1F3FB}','\u{1F385}\u{1F3FC}','\u{1F385}\u{1F3FD}','\u{1F385}\u{1F3FE}','\u{1F385}\u{1F3FF}','\u{1F3C2}\u{1F3FB}','\u{1F3C2}\u{1F3FC}','\u{1F3C2}\u{1F3FD}','\u{1F3C2}\u{1F3FE}','\u{1F3C2}\u{1F3FF}','\u{1F3C3}\u{1F3FB}','\u{1F3C3}\u{1F3FC}','\u{1F3C3}\u{1F3FD}','\u{1F3C3}\u{1F3FE}','\u{1F3C3}\u{1F3FF}','\u{1F3C4}\u{1F3FB}','\u{1F3C4}\u{1F3FC}','\u{1F3C4}\u{1F3FD}','\u{1F3C4}\u{1F3FE}','\u{1F3C4}\u{1F3FF}','\u{1F3C7}\u{1F3FB}','\u{1F3C7}\u{1F3FC}','\u{1F3C7}\u{1F3FD}','\u{1F3C7}\u{1F3FE}','\u{1F3C7}\u{1F3FF}','\u{1F3CA}\u{1F3FB}','\u{1F3CA}\u{1F3FC}','\u{1F3CA}\u{1F3FD}','\u{1F3CA}\u{1F3FE}','\u{1F3CA}\u{1F3FF}','\u{1F3CB}\u{1F3FB}','\u{1F3CB}\u{1F3FC}','\u{1F3CB}\u{1F3FD}','\u{1F3CB}\u{1F3FE}','\u{1F3CB}\u{1F3FF}','\u{1F3CC}\u{1F3FB}','\u{1F3CC}\u{1F3FC}','\u{1F3CC}\u{1F3FD}','\u{1F3CC}\u{1F3FE}','\u{1F3CC}\u{1F3FF}','\u{1F442}\u{1F3FB}','\u{1F442}\u{1F3FC}','\u{1F442}\u{1F3FD}','\u{1F442}\u{1F3FE}','\u{1F442}\u{1F3FF}','\u{1F443}\u{1F3FB}','\u{1F443}\u{1F3FC}','\u{1F443}\u{1F3FD}','\u{1F443}\u{1F3FE}','\u{1F443}\u{1F3FF}','\u{1F446}\u{1F3FB}','\u{1F446}\u{1F3FC}','\u{1F446}\u{1F3FD}','\u{1F446}\u{1F3FE}','\u{1F446}\u{1F3FF}','\u{1F447}\u{1F3FB}','\u{1F447}\u{1F3FC}','\u{1F447}\u{1F3FD}','\u{1F447}\u{1F3FE}','\u{1F447}\u{1F3FF}','\u{1F448}\u{1F3FB}','\u{1F448}\u{1F3FC}','\u{1F448}\u{1F3FD}','\u{1F448}\u{1F3FE}','\u{1F448}\u{1F3FF}','\u{1F449}\u{1F3FB}','\u{1F449}\u{1F3FC}','\u{1F449}\u{1F3FD}','\u{1F449}\u{1F3FE}','\u{1F449}\u{1F3FF}','\u{1F44A}\u{1F3FB}','\u{1F44A}\u{1F3FC}','\u{1F44A}\u{1F3FD}','\u{1F44A}\u{1F3FE}','\u{1F44A}\u{1F3FF}','\u{1F44B}\u{1F3FB}','\u{1F44B}\u{1F3FC}','\u{1F44B}\u{1F3FD}','\u{1F44B}\u{1F3FE}','\u{1F44B}\u{1F3FF}','\u{1F44C}\u{1F3FB}','\u{1F44C}\u{1F3FC}','\u{1F44C}\u{1F3FD}','\u{1F44C}\u{1F3FE}','\u{1F44C}\u{1F3FF}','\u{1F44D}\u{1F3FB}','\u{1F44D}\u{1F3FC}','\u{1F44D}\u{1F3FD}','\u{1F44D}\u{1F3FE}','\u{1F44D}\u{1F3FF}','\u{1F44E}\u{1F3FB}','\u{1F44E}\u{1F3FC}','\u{1F44E}\u{1F3FD}','\u{1F44E}\u{1F3FE}','\u{1F44E}\u{1F3FF}','\u{1F44F}\u{1F3FB}','\u{1F44F}\u{1F3FC}','\u{1F44F}\u{1F3FD}','\u{1F44F}\u{1F3FE}','\u{1F44F}\u{1F3FF}','\u{1F450}\u{1F3FB}','\u{1F450}\u{1F3FC}','\u{1F450}\u{1F3FD}','\u{1F450}\u{1F3FE}','\u{1F450}\u{1F3FF}','\u{1F466}\u{1F3FB}','\u{1F466}\u{1F3FC}','\u{1F466}\u{1F3FD}','\u{1F466}\u{1F3FE}','\u{1F466}\u{1F3FF}','\u{1F467}\u{1F3FB}','\u{1F467}\u{1F3FC}','\u{1F467}\u{1F3FD}','\u{1F467}\u{1F3FE}','\u{1F467}\u{1F3FF}','\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FF}','\u{1F46B}\u{1F3FB}','\u{1F46B}\u{1F3FC}','\u{1F46B}\u{1F3FD}','\u{1F46B}\u{1F3FE}','\u{1F46B}\u{1F3FF}','\u{1F46C}\u{1F3FB}','\u{1F46C}\u{1F3FC}','\u{1F46C}\u{1F3FD}','\u{1F46C}\u{1F3FE}','\u{1F46C}\u{1F3FF}','\u{1F46D}\u{1F3FB}','\u{1F46D}\u{1F3FC}','\u{1F46D}\u{1F3FD}','\u{1F46D}\u{1F3FE}','\u{1F46D}\u{1F3FF}','\u{1F46E}\u{1F3FB}','\u{1F46E}\u{1F3FC}','\u{1F46E}\u{1F3FD}','\u{1F46E}\u{1F3FE}','\u{1F46E}\u{1F3FF}','\u{1F46F}\u{1F3FB}','\u{1F46F}\u{1F3FC}','\u{1F46F}\u{1F3FD}','\u{1F46F}\u{1F3FE}','\u{1F46F}\u{1F3FF}','\u{1F470}\u{1F3FB}','\u{1F470}\u{1F3FC}','\u{1F470}\u{1F3FD}','\u{1F470}\u{1F3FE}','\u{1F470}\u{1F3FF}','\u{1F471}\u{1F3FB}','\u{1F471}\u{1F3FC}','\u{1F471}\u{1F3FD}','\u{1F471}\u{1F3FE}','\u{1F471}\u{1F3FF}','\u{1F472}\u{1F3FB}','\u{1F472}\u{1F3FC}','\u{1F472}\u{1F3FD}','\u{1F472}\u{1F3FE}','\u{1F472}\u{1F3FF}','\u{1F473}\u{1F3FB}','\u{1F473}\u{1F3FC}','\u{1F473}\u{1F3FD}','\u{1F473}\u{1F3FE}','\u{1F473}\u{1F3FF}','\u{1F474}\u{1F3FB}','\u{1F474}\u{1F3FC}','\u{1F474}\u{1F3FD}','\u{1F474}\u{1F3FE}','\u{1F474}\u{1F3FF}','\u{1F475}\u{1F3FB}','\u{1F475}\u{1F3FC}','\u{1F475}\u{1F3FD}','\u{1F475}\u{1F3FE}','\u{1F475}\u{1F3FF}','\u{1F476}\u{1F3FB}','\u{1F476}\u{1F3FC}','\u{1F476}\u{1F3FD}','\u{1F476}\u{1F3FE}','\u{1F476}\u{1F3FF}','\u{1F477}\u{1F3FB}','\u{1F477}\u{1F3FC}','\u{1F477}\u{1F3FD}','\u{1F477}\u{1F3FE}','\u{1F477}\u{1F3FF}','\u{1F478}\u{1F3FB}','\u{1F478}\u{1F3FC}','\u{1F478}\u{1F3FD}','\u{1F478}\u{1F3FE}','\u{1F478}\u{1F3FF}','\u{1F47C}\u{1F3FB}','\u{1F47C}\u{1F3FC}','\u{1F47C}\u{1F3FD}','\u{1F47C}\u{1F3FE}','\u{1F47C}\u{1F3FF}','\u{1F481}\u{1F3FB}','\u{1F481}\u{1F3FC}','\u{1F481}\u{1F3FD}','\u{1F481}\u{1F3FE}','\u{1F481}\u{1F3FF}','\u{1F482}\u{1F3FB}','\u{1F482}\u{1F3FC}','\u{1F482}\u{1F3FD}','\u{1F482}\u{1F3FE}','\u{1F482}\u{1F3FF}','\u{1F483}\u{1F3FB}','\u{1F483}\u{1F3FC}','\u{1F483}\u{1F3FD}','\u{1F483}\u{1F3FE}','\u{1F483}\u{1F3FF}','\u{1F485}\u{1F3FB}','\u{1F485}\u{1F3FC}','\u{1F485}\u{1F3FD}','\u{1F485}\u{1F3FE}','\u{1F485}\u{1F3FF}','\u{1F486}\u{1F3FB}','\u{1F486}\u{1F3FC}','\u{1F486}\u{1F3FD}','\u{1F486}\u{1F3FE}','\u{1F486}\u{1F3FF}','\u{1F487}\u{1F3FB}','\u{1F487}\u{1F3FC}','\u{1F487}\u{1F3FD}','\u{1F487}\u{1F3FE}','\u{1F487}\u{1F3FF}','\u{1F48F}\u{1F3FB}','\u{1F48F}\u{1F3FC}','\u{1F48F}\u{1F3FD}','\u{1F48F}\u{1F3FE}','\u{1F48F}\u{1F3FF}','\u{1F491}\u{1F3FB}','\u{1F491}\u{1F3FC}','\u{1F491}\u{1F3FD}','\u{1F491}\u{1F3FE}','\u{1F491}\u{1F3FF}','\u{1F4AA}\u{1F3FB}','\u{1F4AA}\u{1F3FC}','\u{1F4AA}\u{1F3FD}','\u{1F4AA}\u{1F3FE}','\u{1F4AA}\u{1F3FF}','\u{1F574}\u{1F3FB}','\u{1F574}\u{1F3FC}','\u{1F574}\u{1F3FD}','\u{1F574}\u{1F3FE}','\u{1F574}\u{1F3FF}','\u{1F575}\u{1F3FB}','\u{1F575}\u{1F3FC}','\u{1F575}\u{1F3FD}','\u{1F575}\u{1F3FE}','\u{1F575}\u{1F3FF}','\u{1F57A}\u{1F3FB}','\u{1F57A}\u{1F3FC}','\u{1F57A}\u{1F3FD}','\u{1F57A}\u{1F3FE}','\u{1F57A}\u{1F3FF}','\u{1F590}\u{1F3FB}','\u{1F590}\u{1F3FC}','\u{1F590}\u{1F3FD}','\u{1F590}\u{1F3FE}','\u{1F590}\u{1F3FF}','\u{1F595}\u{1F3FB}','\u{1F595}\u{1F3FC}','\u{1F595}\u{1F3FD}','\u{1F595}\u{1F3FE}','\u{1F595}\u{1F3FF}','\u{1F596}\u{1F3FB}','\u{1F596}\u{1F3FC}','\u{1F596}\u{1F3FD}','\u{1F596}\u{1F3FE}','\u{1F596}\u{1F3FF}','\u{1F645}\u{1F3FB}','\u{1F645}\u{1F3FC}','\u{1F645}\u{1F3FD}','\u{1F645}\u{1F3FE}','\u{1F645}\u{1F3FF}','\u{1F646}\u{1F3FB}','\u{1F646}\u{1F3FC}','\u{1F646}\u{1F3FD}','\u{1F646}\u{1F3FE}','\u{1F646}\u{1F3FF}','\u{1F647}\u{1F3FB}','\u{1F647}\u{1F3FC}','\u{1F647}\u{1F3FD}','\u{1F647}\u{1F3FE}','\u{1F647}\u{1F3FF}','\u{1F64B}\u{1F3FB}','\u{1F64B}\u{1F3FC}','\u{1F64B}\u{1F3FD}','\u{1F64B}\u{1F3FE}','\u{1F64B}\u{1F3FF}','\u{1F64C}\u{1F3FB}','\u{1F64C}\u{1F3FC}','\u{1F64C}\u{1F3FD}','\u{1F64C}\u{1F3FE}','\u{1F64C}\u{1F3FF}','\u{1F64D}\u{1F3FB}','\u{1F64D}\u{1F3FC}','\u{1F64D}\u{1F3FD}','\u{1F64D}\u{1F3FE}','\u{1F64D}\u{1F3FF}','\u{1F64E}\u{1F3FB}','\u{1F64E}\u{1F3FC}','\u{1F64E}\u{1F3FD}','\u{1F64E}\u{1F3FE}','\u{1F64E}\u{1F3FF}','\u{1F64F}\u{1F3FB}','\u{1F64F}\u{1F3FC}','\u{1F64F}\u{1F3FD}','\u{1F64F}\u{1F3FE}','\u{1F64F}\u{1F3FF}','\u{1F6A3}\u{1F3FB}','\u{1F6A3}\u{1F3FC}','\u{1F6A3}\u{1F3FD}','\u{1F6A3}\u{1F3FE}','\u{1F6A3}\u{1F3FF}','\u{1F6B4}\u{1F3FB}','\u{1F6B4}\u{1F3FC}','\u{1F6B4}\u{1F3FD}','\u{1F6B4}\u{1F3FE}','\u{1F6B4}\u{1F3FF}','\u{1F6B5}\u{1F3FB}','\u{1F6B5}\u{1F3FC}','\u{1F6B5}\u{1F3FD}','\u{1F6B5}\u{1F3FE}','\u{1F6B5}\u{1F3FF}','\u{1F6B6}\u{1F3FB}','\u{1F6B6}\u{1F3FC}','\u{1F6B6}\u{1F3FD}','\u{1F6B6}\u{1F3FE}','\u{1F6B6}\u{1F3FF}','\u{1F6C0}\u{1F3FB}','\u{1F6C0}\u{1F3FC}','\u{1F6C0}\u{1F3FD}','\u{1F6C0}\u{1F3FE}','\u{1F6C0}\u{1F3FF}','\u{1F6CC}\u{1F3FB}','\u{1F6CC}\u{1F3FC}','\u{1F6CC}\u{1F3FD}','\u{1F6CC}\u{1F3FE}','\u{1F6CC}\u{1F3FF}','\u{1F90C}\u{1F3FB}','\u{1F90C}\u{1F3FC}','\u{1F90C}\u{1F3FD}','\u{1F90C}\u{1F3FE}','\u{1F90C}\u{1F3FF}','\u{1F90F}\u{1F3FB}','\u{1F90F}\u{1F3FC}','\u{1F90F}\u{1F3FD}','\u{1F90F}\u{1F3FE}','\u{1F90F}\u{1F3FF}','\u{1F918}\u{1F3FB}','\u{1F918}\u{1F3FC}','\u{1F918}\u{1F3FD}','\u{1F918}\u{1F3FE}','\u{1F918}\u{1F3FF}','\u{1F919}\u{1F3FB}','\u{1F919}\u{1F3FC}','\u{1F919}\u{1F3FD}','\u{1F919}\u{1F3FE}','\u{1F919}\u{1F3FF}','\u{1F91A}\u{1F3FB}','\u{1F91A}\u{1F3FC}','\u{1F91A}\u{1F3FD}','\u{1F91A}\u{1F3FE}','\u{1F91A}\u{1F3FF}','\u{1F91B}\u{1F3FB}','\u{1F91B}\u{1F3FC}','\u{1F91B}\u{1F3FD}','\u{1F91B}\u{1F3FE}','\u{1F91B}\u{1F3FF}','\u{1F91C}\u{1F3FB}','\u{1F91C}\u{1F3FC}','\u{1F91C}\u{1F3FD}','\u{1F91C}\u{1F3FE}','\u{1F91C}\u{1F3FF}','\u{1F91D}\u{1F3FB}','\u{1F91D}\u{1F3FC}','\u{1F91D}\u{1F3FD}','\u{1F91D}\u{1F3FE}','\u{1F91D}\u{1F3FF}','\u{1F91E}\u{1F3FB}','\u{1F91E}\u{1F3FC}','\u{1F91E}\u{1F3FD}','\u{1F91E}\u{1F3FE}','\u{1F91E}\u{1F3FF}','\u{1F91F}\u{1F3FB}','\u{1F91F}\u{1F3FC}','\u{1F91F}\u{1F3FD}','\u{1F91F}\u{1F3FE}','\u{1F91F}\u{1F3FF}','\u{1F926}\u{1F3FB}','\u{1F926}\u{1F3FC}','\u{1F926}\u{1F3FD}','\u{1F926}\u{1F3FE}','\u{1F926}\u{1F3FF}','\u{1F930}\u{1F3FB}','\u{1F930}\u{1F3FC}','\u{1F930}\u{1F3FD}','\u{1F930}\u{1F3FE}','\u{1F930}\u{1F3FF}','\u{1F931}\u{1F3FB}','\u{1F931}\u{1F3FC}','\u{1F931}\u{1F3FD}','\u{1F931}\u{1F3FE}','\u{1F931}\u{1F3FF}','\u{1F932}\u{1F3FB}','\u{1F932}\u{1F3FC}','\u{1F932}\u{1F3FD}','\u{1F932}\u{1F3FE}','\u{1F932}\u{1F3FF}','\u{1F933}\u{1F3FB}','\u{1F933}\u{1F3FC}','\u{1F933}\u{1F3FD}','\u{1F933}\u{1F3FE}','\u{1F933}\u{1F3FF}','\u{1F934}\u{1F3FB}','\u{1F934}\u{1F3FC}','\u{1F934}\u{1F3FD}','\u{1F934}\u{1F3FE}','\u{1F934}\u{1F3FF}','\u{1F935}\u{1F3FB}','\u{1F935}\u{1F3FC}','\u{1F935}\u{1F3FD}','\u{1F935}\u{1F3FE}','\u{1F935}\u{1F3FF}','\u{1F936}\u{1F3FB}','\u{1F936}\u{1F3FC}','\u{1F936}\u{1F3FD}','\u{1F936}\u{1F3FE}','\u{1F936}\u{1F3FF}','\u{1F937}\u{1F3FB}','\u{1F937}\u{1F3FC}','\u{1F937}\u{1F3FD}','\u{1F937}\u{1F3FE}','\u{1F937}\u{1F3FF}','\u{1F938}\u{1F3FB}','\u{1F938}\u{1F3FC}','\u{1F938}\u{1F3FD}','\u{1F938}\u{1F3FE}','\u{1F938}\u{1F3FF}','\u{1F939}\u{1F3FB}','\u{1F939}\u{1F3FC}','\u{1F939}\u{1F3FD}','\u{1F939}\u{1F3FE}','\u{1F939}\u{1F3FF}','\u{1F93C}\u{1F3FB}','\u{1F93C}\u{1F3FC}','\u{1F93C}\u{1F3FD}','\u{1F93C}\u{1F3FE}','\u{1F93C}\u{1F3FF}','\u{1F93D}\u{1F3FB}','\u{1F93D}\u{1F3FC}','\u{1F93D}\u{1F3FD}','\u{1F93D}\u{1F3FE}','\u{1F93D}\u{1F3FF}','\u{1F93E}\u{1F3FB}','\u{1F93E}\u{1F3FC}','\u{1F93E}\u{1F3FD}','\u{1F93E}\u{1F3FE}','\u{1F93E}\u{1F3FF}','\u{1F977}\u{1F3FB}','\u{1F977}\u{1F3FC}','\u{1F977}\u{1F3FD}','\u{1F977}\u{1F3FE}','\u{1F977}\u{1F3FF}','\u{1F9B5}\u{1F3FB}','\u{1F9B5}\u{1F3FC}','\u{1F9B5}\u{1F3FD}','\u{1F9B5}\u{1F3FE}','\u{1F9B5}\u{1F3FF}','\u{1F9B6}\u{1F3FB}','\u{1F9B6}\u{1F3FC}','\u{1F9B6}\u{1F3FD}','\u{1F9B6}\u{1F3FE}','\u{1F9B6}\u{1F3FF}','\u{1F9B8}\u{1F3FB}','\u{1F9B8}\u{1F3FC}','\u{1F9B8}\u{1F3FD}','\u{1F9B8}\u{1F3FE}','\u{1F9B8}\u{1F3FF}','\u{1F9B9}\u{1F3FB}','\u{1F9B9}\u{1F3FC}','\u{1F9B9}\u{1F3FD}','\u{1F9B9}\u{1F3FE}','\u{1F9B9}\u{1F3FF}','\u{1F9BB}\u{1F3FB}','\u{1F9BB}\u{1F3FC}','\u{1F9BB}\u{1F3FD}','\u{1F9BB}\u{1F3FE}','\u{1F9BB}\u{1F3FF}','\u{1F9CD}\u{1F3FB}','\u{1F9CD}\u{1F3FC}','\u{1F9CD}\u{1F3FD}','\u{1F9CD}\u{1F3FE}','\u{1F9CD}\u{1F3FF}','\u{1F9CE}\u{1F3FB}','\u{1F9CE}\u{1F3FC}','\u{1F9CE}\u{1F3FD}','\u{1F9CE}\u{1F3FE}','\u{1F9CE}\u{1F3FF}','\u{1F9CF}\u{1F3FB}','\u{1F9CF}\u{1F3FC}','\u{1F9CF}\u{1F3FD}','\u{1F9CF}\u{1F3FE}','\u{1F9CF}\u{1F3FF}','\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FF}','\u{1F9D2}\u{1F3FB}','\u{1F9D2}\u{1F3FC}','\u{1F9D2}\u{1F3FD}','\u{1F9D2}\u{1F3FE}','\u{1F9D2}\u{1F3FF}','\u{1F9D3}\u{1F3FB}','\u{1F9D3}\u{1F3FC}','\u{1F9D3}\u{1F3FD}','\u{1F9D3}\u{1F3FE}','\u{1F9D3}\u{1F3FF}','\u{1F9D4}\u{1F3FB}','\u{1F9D4}\u{1F3FC}','\u{1F9D4}\u{1F3FD}','\u{1F9D4}\u{1F3FE}','\u{1F9D4}\u{1F3FF}','\u{1F9D5}\u{1F3FB}','\u{1F9D5}\u{1F3FC}','\u{1F9D5}\u{1F3FD}','\u{1F9D5}\u{1F3FE}','\u{1F9D5}\u{1F3FF}','\u{1F9D6}\u{1F3FB}','\u{1F9D6}\u{1F3FC}','\u{1F9D6}\u{1F3FD}','\u{1F9D6}\u{1F3FE}','\u{1F9D6}\u{1F3FF}','\u{1F9D7}\u{1F3FB}','\u{1F9D7}\u{1F3FC}','\u{1F9D7}\u{1F3FD}','\u{1F9D7}\u{1F3FE}','\u{1F9D7}\u{1F3FF}','\u{1F9D8}\u{1F3FB}','\u{1F9D8}\u{1F3FC}','\u{1F9D8}\u{1F3FD}','\u{1F9D8}\u{1F3FE}','\u{1F9D8}\u{1F3FF}','\u{1F9D9}\u{1F3FB}','\u{1F9D9}\u{1F3FC}','\u{1F9D9}\u{1F3FD}','\u{1F9D9}\u{1F3FE}','\u{1F9D9}\u{1F3FF}','\u{1F9DA}\u{1F3FB}','\u{1F9DA}\u{1F3FC}','\u{1F9DA}\u{1F3FD}','\u{1F9DA}\u{1F3FE}','\u{1F9DA}\u{1F3FF}','\u{1F9DB}\u{1F3FB}','\u{1F9DB}\u{1F3FC}','\u{1F9DB}\u{1F3FD}','\u{1F9DB}\u{1F3FE}','\u{1F9DB}\u{1F3FF}','\u{1F9DC}\u{1F3FB}','\u{1F9DC}\u{1F3FC}','\u{1F9DC}\u{1F3FD}','\u{1F9DC}\u{1F3FE}','\u{1F9DC}\u{1F3FF}','\u{1F9DD}\u{1F3FB}','\u{1F9DD}\u{1F3FC}','\u{1F9DD}\u{1F3FD}','\u{1F9DD}\u{1F3FE}','\u{1F9DD}\u{1F3FF}','\u{1FAC3}\u{1F3FB}','\u{1FAC3}\u{1F3FC}','\u{1FAC3}\u{1F3FD}','\u{1FAC3}\u{1F3FE}','\u{1FAC3}\u{1F3FF}','\u{1FAC4}\u{1F3FB}','\u{1FAC4}\u{1F3FC}','\u{1FAC4}\u{1F3FD}','\u{1FAC4}\u{1F3FE}','\u{1FAC4}\u{1F3FF}','\u{1FAC5}\u{1F3FB}','\u{1FAC5}\u{1F3FC}','\u{1FAC5}\u{1F3FD}','\u{1FAC5}\u{1F3FE}','\u{1FAC5}\u{1F3FF}','\u{1FAF0}\u{1F3FB}','\u{1FAF0}\u{1F3FC}','\u{1FAF0}\u{1F3FD}','\u{1FAF0}\u{1F3FE}','\u{1FAF0}\u{1F3FF}','\u{1FAF1}\u{1F3FB}','\u{1FAF1}\u{1F3FC}','\u{1FAF1}\u{1F3FD}','\u{1FAF1}\u{1F3FE}','\u{1FAF1}\u{1F3FF}','\u{1FAF2}\u{1F3FB}','\u{1FAF2}\u{1F3FC}','\u{1FAF2}\u{1F3FD}','\u{1FAF2}\u{1F3FE}','\u{1FAF2}\u{1F3FF}','\u{1FAF3}\u{1F3FB}','\u{1FAF3}\u{1F3FC}','\u{1FAF3}\u{1F3FD}','\u{1FAF3}\u{1F3FE}','\u{1FAF3}\u{1F3FF}','\u{1FAF4}\u{1F3FB}','\u{1FAF4}\u{1F3FC}','\u{1FAF4}\u{1F3FD}','\u{1FAF4}\u{1F3FE}','\u{1FAF4}\u{1F3FF}','\u{1FAF5}\u{1F3FB}','\u{1FAF5}\u{1F3FC}','\u{1FAF5}\u{1F3FD}','\u{1FAF5}\u{1F3FE}','\u{1FAF5}\u{1F3FF}','\u{1FAF6}\u{1F3FB}','\u{1FAF6}\u{1F3FC}','\u{1FAF6}\u{1F3FD}','\u{1FAF6}\u{1F3FE}','\u{1FAF6}\u{1F3FF}','\u{1FAF7}\u{1F3FB}','\u{1FAF7}\u{1F3FC}','\u{1FAF7}\u{1F3FD}','\u{1FAF7}\u{1F3FE}','\u{1FAF7}\u{1F3FF}','\u{1FAF8}\u{1F3FB}','\u{1FAF8}\u{1F3FC}','\u{1FAF8}\u{1F3FD}','\u{1FAF8}\u{1F3FE}','\u{1FAF8}\u{1F3FF}']; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_Tag_Sequence.js b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_Tag_Sequence.js new file mode 100644 index 0000000000000000000000000000000000000000..eacb53b6377a04cdb6c8094e3411f0acc34607b8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_Tag_Sequence.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(); + +exports.characters = set; +exports.strings = ['\u{1F3F4}\u{E0067}\u{E0062}\u{E0065}\u{E006E}\u{E0067}\u{E007F}','\u{1F3F4}\u{E0067}\u{E0062}\u{E0073}\u{E0063}\u{E0074}\u{E007F}','\u{1F3F4}\u{E0067}\u{E0062}\u{E0077}\u{E006C}\u{E0073}\u{E007F}']; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_ZWJ_Sequence.js b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_ZWJ_Sequence.js new file mode 100644 index 0000000000000000000000000000000000000000..7e3e7dc58ead348fa13de05ba622a0485c27262d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_ZWJ_Sequence.js @@ -0,0 +1,4 @@ +const set = require('regenerate')(); + +exports.characters = set; +exports.strings = ['\u{1F468}\u200D\u2764\uFE0F\u200D\u{1F468}','\u{1F468}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}','\u{1F468}\u200D\u{1F466}','\u{1F468}\u200D\u{1F466}\u200D\u{1F466}','\u{1F468}\u200D\u{1F467}','\u{1F468}\u200D\u{1F467}\u200D\u{1F466}','\u{1F468}\u200D\u{1F467}\u200D\u{1F467}','\u{1F468}\u200D\u{1F468}\u200D\u{1F466}','\u{1F468}\u200D\u{1F468}\u200D\u{1F466}\u200D\u{1F466}','\u{1F468}\u200D\u{1F468}\u200D\u{1F467}','\u{1F468}\u200D\u{1F468}\u200D\u{1F467}\u200D\u{1F466}','\u{1F468}\u200D\u{1F468}\u200D\u{1F467}\u200D\u{1F467}','\u{1F468}\u200D\u{1F469}\u200D\u{1F466}','\u{1F468}\u200D\u{1F469}\u200D\u{1F466}\u200D\u{1F466}','\u{1F468}\u200D\u{1F469}\u200D\u{1F467}','\u{1F468}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F466}','\u{1F468}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F467}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F468}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F468}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FB}','\u{1F468}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FC}','\u{1F468}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FD}','\u{1F468}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F468}','\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F469}','\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}','\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}','\u{1F469}\u200D\u{1F466}','\u{1F469}\u200D\u{1F466}\u200D\u{1F466}','\u{1F469}\u200D\u{1F467}','\u{1F469}\u200D\u{1F467}\u200D\u{1F466}','\u{1F469}\u200D\u{1F467}\u200D\u{1F467}','\u{1F469}\u200D\u{1F469}\u200D\u{1F466}','\u{1F469}\u200D\u{1F469}\u200D\u{1F466}\u200D\u{1F466}','\u{1F469}\u200D\u{1F469}\u200D\u{1F467}','\u{1F469}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F466}','\u{1F469}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F467}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}\u{1F3FF}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FF}','\u{1F469}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F468}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F469}\u{1F3FE}','\u{1F469}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FB}','\u{1F469}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FC}','\u{1F469}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FD}','\u{1F469}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F469}\u{1F3FE}','\u{1F9D1}\u200D\u{1F91D}\u200D\u{1F9D1}','\u{1F9D1}\u200D\u{1F9D1}\u200D\u{1F9D2}','\u{1F9D1}\u200D\u{1F9D1}\u200D\u{1F9D2}\u200D\u{1F9D2}','\u{1F9D1}\u200D\u{1F9D2}','\u{1F9D1}\u200D\u{1F9D2}\u200D\u{1F9D2}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FB}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FB}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FC}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FC}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FD}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FE}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FE}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FF}\u200D\u2764\uFE0F\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FF}\u200D\u{1F91D}\u200D\u{1F9D1}\u{1F3FF}','\u{1FAF1}\u{1F3FB}\u200D\u{1FAF2}\u{1F3FC}','\u{1FAF1}\u{1F3FB}\u200D\u{1FAF2}\u{1F3FD}','\u{1FAF1}\u{1F3FB}\u200D\u{1FAF2}\u{1F3FE}','\u{1FAF1}\u{1F3FB}\u200D\u{1FAF2}\u{1F3FF}','\u{1FAF1}\u{1F3FC}\u200D\u{1FAF2}\u{1F3FB}','\u{1FAF1}\u{1F3FC}\u200D\u{1FAF2}\u{1F3FD}','\u{1FAF1}\u{1F3FC}\u200D\u{1FAF2}\u{1F3FE}','\u{1FAF1}\u{1F3FC}\u200D\u{1FAF2}\u{1F3FF}','\u{1FAF1}\u{1F3FD}\u200D\u{1FAF2}\u{1F3FB}','\u{1FAF1}\u{1F3FD}\u200D\u{1FAF2}\u{1F3FC}','\u{1FAF1}\u{1F3FD}\u200D\u{1FAF2}\u{1F3FE}','\u{1FAF1}\u{1F3FD}\u200D\u{1FAF2}\u{1F3FF}','\u{1FAF1}\u{1F3FE}\u200D\u{1FAF2}\u{1F3FB}','\u{1FAF1}\u{1F3FE}\u200D\u{1FAF2}\u{1F3FC}','\u{1FAF1}\u{1F3FE}\u200D\u{1FAF2}\u{1F3FD}','\u{1FAF1}\u{1F3FE}\u200D\u{1FAF2}\u{1F3FF}','\u{1FAF1}\u{1F3FF}\u200D\u{1FAF2}\u{1F3FB}','\u{1FAF1}\u{1F3FF}\u200D\u{1FAF2}\u{1F3FC}','\u{1FAF1}\u{1F3FF}\u200D\u{1FAF2}\u{1F3FD}','\u{1FAF1}\u{1F3FF}\u200D\u{1FAF2}\u{1F3FE}','\u{1F3C3}\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FB}\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FC}\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FD}\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FE}\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FF}\u200D\u27A1\uFE0F','\u{1F468}\u200D\u2695\uFE0F','\u{1F468}\u200D\u2696\uFE0F','\u{1F468}\u200D\u2708\uFE0F','\u{1F468}\u200D\u{1F33E}','\u{1F468}\u200D\u{1F373}','\u{1F468}\u200D\u{1F37C}','\u{1F468}\u200D\u{1F393}','\u{1F468}\u200D\u{1F3A4}','\u{1F468}\u200D\u{1F3A8}','\u{1F468}\u200D\u{1F3EB}','\u{1F468}\u200D\u{1F3ED}','\u{1F468}\u200D\u{1F4BB}','\u{1F468}\u200D\u{1F4BC}','\u{1F468}\u200D\u{1F527}','\u{1F468}\u200D\u{1F52C}','\u{1F468}\u200D\u{1F680}','\u{1F468}\u200D\u{1F692}','\u{1F468}\u200D\u{1F9AF}','\u{1F468}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F468}\u200D\u{1F9BC}','\u{1F468}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F468}\u200D\u{1F9BD}','\u{1F468}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FB}\u200D\u2695\uFE0F','\u{1F468}\u{1F3FB}\u200D\u2696\uFE0F','\u{1F468}\u{1F3FB}\u200D\u2708\uFE0F','\u{1F468}\u{1F3FB}\u200D\u{1F33E}','\u{1F468}\u{1F3FB}\u200D\u{1F373}','\u{1F468}\u{1F3FB}\u200D\u{1F37C}','\u{1F468}\u{1F3FB}\u200D\u{1F393}','\u{1F468}\u{1F3FB}\u200D\u{1F3A4}','\u{1F468}\u{1F3FB}\u200D\u{1F3A8}','\u{1F468}\u{1F3FB}\u200D\u{1F3EB}','\u{1F468}\u{1F3FB}\u200D\u{1F3ED}','\u{1F468}\u{1F3FB}\u200D\u{1F4BB}','\u{1F468}\u{1F3FB}\u200D\u{1F4BC}','\u{1F468}\u{1F3FB}\u200D\u{1F527}','\u{1F468}\u{1F3FB}\u200D\u{1F52C}','\u{1F468}\u{1F3FB}\u200D\u{1F680}','\u{1F468}\u{1F3FB}\u200D\u{1F692}','\u{1F468}\u{1F3FB}\u200D\u{1F9AF}','\u{1F468}\u{1F3FB}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FB}\u200D\u{1F9BC}','\u{1F468}\u{1F3FB}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FB}\u200D\u{1F9BD}','\u{1F468}\u{1F3FB}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FC}\u200D\u2695\uFE0F','\u{1F468}\u{1F3FC}\u200D\u2696\uFE0F','\u{1F468}\u{1F3FC}\u200D\u2708\uFE0F','\u{1F468}\u{1F3FC}\u200D\u{1F33E}','\u{1F468}\u{1F3FC}\u200D\u{1F373}','\u{1F468}\u{1F3FC}\u200D\u{1F37C}','\u{1F468}\u{1F3FC}\u200D\u{1F393}','\u{1F468}\u{1F3FC}\u200D\u{1F3A4}','\u{1F468}\u{1F3FC}\u200D\u{1F3A8}','\u{1F468}\u{1F3FC}\u200D\u{1F3EB}','\u{1F468}\u{1F3FC}\u200D\u{1F3ED}','\u{1F468}\u{1F3FC}\u200D\u{1F4BB}','\u{1F468}\u{1F3FC}\u200D\u{1F4BC}','\u{1F468}\u{1F3FC}\u200D\u{1F527}','\u{1F468}\u{1F3FC}\u200D\u{1F52C}','\u{1F468}\u{1F3FC}\u200D\u{1F680}','\u{1F468}\u{1F3FC}\u200D\u{1F692}','\u{1F468}\u{1F3FC}\u200D\u{1F9AF}','\u{1F468}\u{1F3FC}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FC}\u200D\u{1F9BC}','\u{1F468}\u{1F3FC}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FC}\u200D\u{1F9BD}','\u{1F468}\u{1F3FC}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FD}\u200D\u2695\uFE0F','\u{1F468}\u{1F3FD}\u200D\u2696\uFE0F','\u{1F468}\u{1F3FD}\u200D\u2708\uFE0F','\u{1F468}\u{1F3FD}\u200D\u{1F33E}','\u{1F468}\u{1F3FD}\u200D\u{1F373}','\u{1F468}\u{1F3FD}\u200D\u{1F37C}','\u{1F468}\u{1F3FD}\u200D\u{1F393}','\u{1F468}\u{1F3FD}\u200D\u{1F3A4}','\u{1F468}\u{1F3FD}\u200D\u{1F3A8}','\u{1F468}\u{1F3FD}\u200D\u{1F3EB}','\u{1F468}\u{1F3FD}\u200D\u{1F3ED}','\u{1F468}\u{1F3FD}\u200D\u{1F4BB}','\u{1F468}\u{1F3FD}\u200D\u{1F4BC}','\u{1F468}\u{1F3FD}\u200D\u{1F527}','\u{1F468}\u{1F3FD}\u200D\u{1F52C}','\u{1F468}\u{1F3FD}\u200D\u{1F680}','\u{1F468}\u{1F3FD}\u200D\u{1F692}','\u{1F468}\u{1F3FD}\u200D\u{1F9AF}','\u{1F468}\u{1F3FD}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FD}\u200D\u{1F9BC}','\u{1F468}\u{1F3FD}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FD}\u200D\u{1F9BD}','\u{1F468}\u{1F3FD}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FE}\u200D\u2695\uFE0F','\u{1F468}\u{1F3FE}\u200D\u2696\uFE0F','\u{1F468}\u{1F3FE}\u200D\u2708\uFE0F','\u{1F468}\u{1F3FE}\u200D\u{1F33E}','\u{1F468}\u{1F3FE}\u200D\u{1F373}','\u{1F468}\u{1F3FE}\u200D\u{1F37C}','\u{1F468}\u{1F3FE}\u200D\u{1F393}','\u{1F468}\u{1F3FE}\u200D\u{1F3A4}','\u{1F468}\u{1F3FE}\u200D\u{1F3A8}','\u{1F468}\u{1F3FE}\u200D\u{1F3EB}','\u{1F468}\u{1F3FE}\u200D\u{1F3ED}','\u{1F468}\u{1F3FE}\u200D\u{1F4BB}','\u{1F468}\u{1F3FE}\u200D\u{1F4BC}','\u{1F468}\u{1F3FE}\u200D\u{1F527}','\u{1F468}\u{1F3FE}\u200D\u{1F52C}','\u{1F468}\u{1F3FE}\u200D\u{1F680}','\u{1F468}\u{1F3FE}\u200D\u{1F692}','\u{1F468}\u{1F3FE}\u200D\u{1F9AF}','\u{1F468}\u{1F3FE}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FE}\u200D\u{1F9BC}','\u{1F468}\u{1F3FE}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FE}\u200D\u{1F9BD}','\u{1F468}\u{1F3FE}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FF}\u200D\u2695\uFE0F','\u{1F468}\u{1F3FF}\u200D\u2696\uFE0F','\u{1F468}\u{1F3FF}\u200D\u2708\uFE0F','\u{1F468}\u{1F3FF}\u200D\u{1F33E}','\u{1F468}\u{1F3FF}\u200D\u{1F373}','\u{1F468}\u{1F3FF}\u200D\u{1F37C}','\u{1F468}\u{1F3FF}\u200D\u{1F393}','\u{1F468}\u{1F3FF}\u200D\u{1F3A4}','\u{1F468}\u{1F3FF}\u200D\u{1F3A8}','\u{1F468}\u{1F3FF}\u200D\u{1F3EB}','\u{1F468}\u{1F3FF}\u200D\u{1F3ED}','\u{1F468}\u{1F3FF}\u200D\u{1F4BB}','\u{1F468}\u{1F3FF}\u200D\u{1F4BC}','\u{1F468}\u{1F3FF}\u200D\u{1F527}','\u{1F468}\u{1F3FF}\u200D\u{1F52C}','\u{1F468}\u{1F3FF}\u200D\u{1F680}','\u{1F468}\u{1F3FF}\u200D\u{1F692}','\u{1F468}\u{1F3FF}\u200D\u{1F9AF}','\u{1F468}\u{1F3FF}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FF}\u200D\u{1F9BC}','\u{1F468}\u{1F3FF}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F468}\u{1F3FF}\u200D\u{1F9BD}','\u{1F468}\u{1F3FF}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F469}\u200D\u2695\uFE0F','\u{1F469}\u200D\u2696\uFE0F','\u{1F469}\u200D\u2708\uFE0F','\u{1F469}\u200D\u{1F33E}','\u{1F469}\u200D\u{1F373}','\u{1F469}\u200D\u{1F37C}','\u{1F469}\u200D\u{1F393}','\u{1F469}\u200D\u{1F3A4}','\u{1F469}\u200D\u{1F3A8}','\u{1F469}\u200D\u{1F3EB}','\u{1F469}\u200D\u{1F3ED}','\u{1F469}\u200D\u{1F4BB}','\u{1F469}\u200D\u{1F4BC}','\u{1F469}\u200D\u{1F527}','\u{1F469}\u200D\u{1F52C}','\u{1F469}\u200D\u{1F680}','\u{1F469}\u200D\u{1F692}','\u{1F469}\u200D\u{1F9AF}','\u{1F469}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F469}\u200D\u{1F9BC}','\u{1F469}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F469}\u200D\u{1F9BD}','\u{1F469}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FB}\u200D\u2695\uFE0F','\u{1F469}\u{1F3FB}\u200D\u2696\uFE0F','\u{1F469}\u{1F3FB}\u200D\u2708\uFE0F','\u{1F469}\u{1F3FB}\u200D\u{1F33E}','\u{1F469}\u{1F3FB}\u200D\u{1F373}','\u{1F469}\u{1F3FB}\u200D\u{1F37C}','\u{1F469}\u{1F3FB}\u200D\u{1F393}','\u{1F469}\u{1F3FB}\u200D\u{1F3A4}','\u{1F469}\u{1F3FB}\u200D\u{1F3A8}','\u{1F469}\u{1F3FB}\u200D\u{1F3EB}','\u{1F469}\u{1F3FB}\u200D\u{1F3ED}','\u{1F469}\u{1F3FB}\u200D\u{1F4BB}','\u{1F469}\u{1F3FB}\u200D\u{1F4BC}','\u{1F469}\u{1F3FB}\u200D\u{1F527}','\u{1F469}\u{1F3FB}\u200D\u{1F52C}','\u{1F469}\u{1F3FB}\u200D\u{1F680}','\u{1F469}\u{1F3FB}\u200D\u{1F692}','\u{1F469}\u{1F3FB}\u200D\u{1F9AF}','\u{1F469}\u{1F3FB}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FB}\u200D\u{1F9BC}','\u{1F469}\u{1F3FB}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FB}\u200D\u{1F9BD}','\u{1F469}\u{1F3FB}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FC}\u200D\u2695\uFE0F','\u{1F469}\u{1F3FC}\u200D\u2696\uFE0F','\u{1F469}\u{1F3FC}\u200D\u2708\uFE0F','\u{1F469}\u{1F3FC}\u200D\u{1F33E}','\u{1F469}\u{1F3FC}\u200D\u{1F373}','\u{1F469}\u{1F3FC}\u200D\u{1F37C}','\u{1F469}\u{1F3FC}\u200D\u{1F393}','\u{1F469}\u{1F3FC}\u200D\u{1F3A4}','\u{1F469}\u{1F3FC}\u200D\u{1F3A8}','\u{1F469}\u{1F3FC}\u200D\u{1F3EB}','\u{1F469}\u{1F3FC}\u200D\u{1F3ED}','\u{1F469}\u{1F3FC}\u200D\u{1F4BB}','\u{1F469}\u{1F3FC}\u200D\u{1F4BC}','\u{1F469}\u{1F3FC}\u200D\u{1F527}','\u{1F469}\u{1F3FC}\u200D\u{1F52C}','\u{1F469}\u{1F3FC}\u200D\u{1F680}','\u{1F469}\u{1F3FC}\u200D\u{1F692}','\u{1F469}\u{1F3FC}\u200D\u{1F9AF}','\u{1F469}\u{1F3FC}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FC}\u200D\u{1F9BC}','\u{1F469}\u{1F3FC}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FC}\u200D\u{1F9BD}','\u{1F469}\u{1F3FC}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FD}\u200D\u2695\uFE0F','\u{1F469}\u{1F3FD}\u200D\u2696\uFE0F','\u{1F469}\u{1F3FD}\u200D\u2708\uFE0F','\u{1F469}\u{1F3FD}\u200D\u{1F33E}','\u{1F469}\u{1F3FD}\u200D\u{1F373}','\u{1F469}\u{1F3FD}\u200D\u{1F37C}','\u{1F469}\u{1F3FD}\u200D\u{1F393}','\u{1F469}\u{1F3FD}\u200D\u{1F3A4}','\u{1F469}\u{1F3FD}\u200D\u{1F3A8}','\u{1F469}\u{1F3FD}\u200D\u{1F3EB}','\u{1F469}\u{1F3FD}\u200D\u{1F3ED}','\u{1F469}\u{1F3FD}\u200D\u{1F4BB}','\u{1F469}\u{1F3FD}\u200D\u{1F4BC}','\u{1F469}\u{1F3FD}\u200D\u{1F527}','\u{1F469}\u{1F3FD}\u200D\u{1F52C}','\u{1F469}\u{1F3FD}\u200D\u{1F680}','\u{1F469}\u{1F3FD}\u200D\u{1F692}','\u{1F469}\u{1F3FD}\u200D\u{1F9AF}','\u{1F469}\u{1F3FD}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FD}\u200D\u{1F9BC}','\u{1F469}\u{1F3FD}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FD}\u200D\u{1F9BD}','\u{1F469}\u{1F3FD}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FE}\u200D\u2695\uFE0F','\u{1F469}\u{1F3FE}\u200D\u2696\uFE0F','\u{1F469}\u{1F3FE}\u200D\u2708\uFE0F','\u{1F469}\u{1F3FE}\u200D\u{1F33E}','\u{1F469}\u{1F3FE}\u200D\u{1F373}','\u{1F469}\u{1F3FE}\u200D\u{1F37C}','\u{1F469}\u{1F3FE}\u200D\u{1F393}','\u{1F469}\u{1F3FE}\u200D\u{1F3A4}','\u{1F469}\u{1F3FE}\u200D\u{1F3A8}','\u{1F469}\u{1F3FE}\u200D\u{1F3EB}','\u{1F469}\u{1F3FE}\u200D\u{1F3ED}','\u{1F469}\u{1F3FE}\u200D\u{1F4BB}','\u{1F469}\u{1F3FE}\u200D\u{1F4BC}','\u{1F469}\u{1F3FE}\u200D\u{1F527}','\u{1F469}\u{1F3FE}\u200D\u{1F52C}','\u{1F469}\u{1F3FE}\u200D\u{1F680}','\u{1F469}\u{1F3FE}\u200D\u{1F692}','\u{1F469}\u{1F3FE}\u200D\u{1F9AF}','\u{1F469}\u{1F3FE}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FE}\u200D\u{1F9BC}','\u{1F469}\u{1F3FE}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FE}\u200D\u{1F9BD}','\u{1F469}\u{1F3FE}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FF}\u200D\u2695\uFE0F','\u{1F469}\u{1F3FF}\u200D\u2696\uFE0F','\u{1F469}\u{1F3FF}\u200D\u2708\uFE0F','\u{1F469}\u{1F3FF}\u200D\u{1F33E}','\u{1F469}\u{1F3FF}\u200D\u{1F373}','\u{1F469}\u{1F3FF}\u200D\u{1F37C}','\u{1F469}\u{1F3FF}\u200D\u{1F393}','\u{1F469}\u{1F3FF}\u200D\u{1F3A4}','\u{1F469}\u{1F3FF}\u200D\u{1F3A8}','\u{1F469}\u{1F3FF}\u200D\u{1F3EB}','\u{1F469}\u{1F3FF}\u200D\u{1F3ED}','\u{1F469}\u{1F3FF}\u200D\u{1F4BB}','\u{1F469}\u{1F3FF}\u200D\u{1F4BC}','\u{1F469}\u{1F3FF}\u200D\u{1F527}','\u{1F469}\u{1F3FF}\u200D\u{1F52C}','\u{1F469}\u{1F3FF}\u200D\u{1F680}','\u{1F469}\u{1F3FF}\u200D\u{1F692}','\u{1F469}\u{1F3FF}\u200D\u{1F9AF}','\u{1F469}\u{1F3FF}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FF}\u200D\u{1F9BC}','\u{1F469}\u{1F3FF}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F469}\u{1F3FF}\u200D\u{1F9BD}','\u{1F469}\u{1F3FF}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F6B6}\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FB}\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FC}\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FD}\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FE}\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FF}\u200D\u27A1\uFE0F','\u{1F9CE}\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FB}\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FC}\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FD}\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FE}\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FF}\u200D\u27A1\uFE0F','\u{1F9D1}\u200D\u2695\uFE0F','\u{1F9D1}\u200D\u2696\uFE0F','\u{1F9D1}\u200D\u2708\uFE0F','\u{1F9D1}\u200D\u{1F33E}','\u{1F9D1}\u200D\u{1F373}','\u{1F9D1}\u200D\u{1F37C}','\u{1F9D1}\u200D\u{1F384}','\u{1F9D1}\u200D\u{1F393}','\u{1F9D1}\u200D\u{1F3A4}','\u{1F9D1}\u200D\u{1F3A8}','\u{1F9D1}\u200D\u{1F3EB}','\u{1F9D1}\u200D\u{1F3ED}','\u{1F9D1}\u200D\u{1F4BB}','\u{1F9D1}\u200D\u{1F4BC}','\u{1F9D1}\u200D\u{1F527}','\u{1F9D1}\u200D\u{1F52C}','\u{1F9D1}\u200D\u{1F680}','\u{1F9D1}\u200D\u{1F692}','\u{1F9D1}\u200D\u{1F9AF}','\u{1F9D1}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F9D1}\u200D\u{1F9BC}','\u{1F9D1}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F9D1}\u200D\u{1F9BD}','\u{1F9D1}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FB}\u200D\u2695\uFE0F','\u{1F9D1}\u{1F3FB}\u200D\u2696\uFE0F','\u{1F9D1}\u{1F3FB}\u200D\u2708\uFE0F','\u{1F9D1}\u{1F3FB}\u200D\u{1F33E}','\u{1F9D1}\u{1F3FB}\u200D\u{1F373}','\u{1F9D1}\u{1F3FB}\u200D\u{1F37C}','\u{1F9D1}\u{1F3FB}\u200D\u{1F384}','\u{1F9D1}\u{1F3FB}\u200D\u{1F393}','\u{1F9D1}\u{1F3FB}\u200D\u{1F3A4}','\u{1F9D1}\u{1F3FB}\u200D\u{1F3A8}','\u{1F9D1}\u{1F3FB}\u200D\u{1F3EB}','\u{1F9D1}\u{1F3FB}\u200D\u{1F3ED}','\u{1F9D1}\u{1F3FB}\u200D\u{1F4BB}','\u{1F9D1}\u{1F3FB}\u200D\u{1F4BC}','\u{1F9D1}\u{1F3FB}\u200D\u{1F527}','\u{1F9D1}\u{1F3FB}\u200D\u{1F52C}','\u{1F9D1}\u{1F3FB}\u200D\u{1F680}','\u{1F9D1}\u{1F3FB}\u200D\u{1F692}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9AF}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FB}\u200D\u{1F9BC}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FB}\u200D\u{1F9BD}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FC}\u200D\u2695\uFE0F','\u{1F9D1}\u{1F3FC}\u200D\u2696\uFE0F','\u{1F9D1}\u{1F3FC}\u200D\u2708\uFE0F','\u{1F9D1}\u{1F3FC}\u200D\u{1F33E}','\u{1F9D1}\u{1F3FC}\u200D\u{1F373}','\u{1F9D1}\u{1F3FC}\u200D\u{1F37C}','\u{1F9D1}\u{1F3FC}\u200D\u{1F384}','\u{1F9D1}\u{1F3FC}\u200D\u{1F393}','\u{1F9D1}\u{1F3FC}\u200D\u{1F3A4}','\u{1F9D1}\u{1F3FC}\u200D\u{1F3A8}','\u{1F9D1}\u{1F3FC}\u200D\u{1F3EB}','\u{1F9D1}\u{1F3FC}\u200D\u{1F3ED}','\u{1F9D1}\u{1F3FC}\u200D\u{1F4BB}','\u{1F9D1}\u{1F3FC}\u200D\u{1F4BC}','\u{1F9D1}\u{1F3FC}\u200D\u{1F527}','\u{1F9D1}\u{1F3FC}\u200D\u{1F52C}','\u{1F9D1}\u{1F3FC}\u200D\u{1F680}','\u{1F9D1}\u{1F3FC}\u200D\u{1F692}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9AF}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FC}\u200D\u{1F9BC}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FC}\u200D\u{1F9BD}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FD}\u200D\u2695\uFE0F','\u{1F9D1}\u{1F3FD}\u200D\u2696\uFE0F','\u{1F9D1}\u{1F3FD}\u200D\u2708\uFE0F','\u{1F9D1}\u{1F3FD}\u200D\u{1F33E}','\u{1F9D1}\u{1F3FD}\u200D\u{1F373}','\u{1F9D1}\u{1F3FD}\u200D\u{1F37C}','\u{1F9D1}\u{1F3FD}\u200D\u{1F384}','\u{1F9D1}\u{1F3FD}\u200D\u{1F393}','\u{1F9D1}\u{1F3FD}\u200D\u{1F3A4}','\u{1F9D1}\u{1F3FD}\u200D\u{1F3A8}','\u{1F9D1}\u{1F3FD}\u200D\u{1F3EB}','\u{1F9D1}\u{1F3FD}\u200D\u{1F3ED}','\u{1F9D1}\u{1F3FD}\u200D\u{1F4BB}','\u{1F9D1}\u{1F3FD}\u200D\u{1F4BC}','\u{1F9D1}\u{1F3FD}\u200D\u{1F527}','\u{1F9D1}\u{1F3FD}\u200D\u{1F52C}','\u{1F9D1}\u{1F3FD}\u200D\u{1F680}','\u{1F9D1}\u{1F3FD}\u200D\u{1F692}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9AF}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FD}\u200D\u{1F9BC}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FD}\u200D\u{1F9BD}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FE}\u200D\u2695\uFE0F','\u{1F9D1}\u{1F3FE}\u200D\u2696\uFE0F','\u{1F9D1}\u{1F3FE}\u200D\u2708\uFE0F','\u{1F9D1}\u{1F3FE}\u200D\u{1F33E}','\u{1F9D1}\u{1F3FE}\u200D\u{1F373}','\u{1F9D1}\u{1F3FE}\u200D\u{1F37C}','\u{1F9D1}\u{1F3FE}\u200D\u{1F384}','\u{1F9D1}\u{1F3FE}\u200D\u{1F393}','\u{1F9D1}\u{1F3FE}\u200D\u{1F3A4}','\u{1F9D1}\u{1F3FE}\u200D\u{1F3A8}','\u{1F9D1}\u{1F3FE}\u200D\u{1F3EB}','\u{1F9D1}\u{1F3FE}\u200D\u{1F3ED}','\u{1F9D1}\u{1F3FE}\u200D\u{1F4BB}','\u{1F9D1}\u{1F3FE}\u200D\u{1F4BC}','\u{1F9D1}\u{1F3FE}\u200D\u{1F527}','\u{1F9D1}\u{1F3FE}\u200D\u{1F52C}','\u{1F9D1}\u{1F3FE}\u200D\u{1F680}','\u{1F9D1}\u{1F3FE}\u200D\u{1F692}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9AF}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FE}\u200D\u{1F9BC}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FE}\u200D\u{1F9BD}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FF}\u200D\u2695\uFE0F','\u{1F9D1}\u{1F3FF}\u200D\u2696\uFE0F','\u{1F9D1}\u{1F3FF}\u200D\u2708\uFE0F','\u{1F9D1}\u{1F3FF}\u200D\u{1F33E}','\u{1F9D1}\u{1F3FF}\u200D\u{1F373}','\u{1F9D1}\u{1F3FF}\u200D\u{1F37C}','\u{1F9D1}\u{1F3FF}\u200D\u{1F384}','\u{1F9D1}\u{1F3FF}\u200D\u{1F393}','\u{1F9D1}\u{1F3FF}\u200D\u{1F3A4}','\u{1F9D1}\u{1F3FF}\u200D\u{1F3A8}','\u{1F9D1}\u{1F3FF}\u200D\u{1F3EB}','\u{1F9D1}\u{1F3FF}\u200D\u{1F3ED}','\u{1F9D1}\u{1F3FF}\u200D\u{1F4BB}','\u{1F9D1}\u{1F3FF}\u200D\u{1F4BC}','\u{1F9D1}\u{1F3FF}\u200D\u{1F527}','\u{1F9D1}\u{1F3FF}\u200D\u{1F52C}','\u{1F9D1}\u{1F3FF}\u200D\u{1F680}','\u{1F9D1}\u{1F3FF}\u200D\u{1F692}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9AF}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9AF}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FF}\u200D\u{1F9BC}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9BC}\u200D\u27A1\uFE0F','\u{1F9D1}\u{1F3FF}\u200D\u{1F9BD}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9BD}\u200D\u27A1\uFE0F','\u26F9\u{1F3FB}\u200D\u2640\uFE0F','\u26F9\u{1F3FB}\u200D\u2642\uFE0F','\u26F9\u{1F3FC}\u200D\u2640\uFE0F','\u26F9\u{1F3FC}\u200D\u2642\uFE0F','\u26F9\u{1F3FD}\u200D\u2640\uFE0F','\u26F9\u{1F3FD}\u200D\u2642\uFE0F','\u26F9\u{1F3FE}\u200D\u2640\uFE0F','\u26F9\u{1F3FE}\u200D\u2642\uFE0F','\u26F9\u{1F3FF}\u200D\u2640\uFE0F','\u26F9\u{1F3FF}\u200D\u2642\uFE0F','\u26F9\uFE0F\u200D\u2640\uFE0F','\u26F9\uFE0F\u200D\u2642\uFE0F','\u{1F3C3}\u200D\u2640\uFE0F','\u{1F3C3}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u200D\u2642\uFE0F','\u{1F3C3}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F3C3}\u{1F3FB}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F3C3}\u{1F3FB}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F3C3}\u{1F3FC}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F3C3}\u{1F3FC}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F3C3}\u{1F3FD}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F3C3}\u{1F3FD}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F3C3}\u{1F3FE}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F3C3}\u{1F3FE}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F3C3}\u{1F3FF}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F3C3}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F3C3}\u{1F3FF}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F3C4}\u200D\u2640\uFE0F','\u{1F3C4}\u200D\u2642\uFE0F','\u{1F3C4}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F3C4}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F3C4}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F3C4}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F3C4}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F3C4}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F3C4}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F3C4}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F3C4}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F3C4}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F3CA}\u200D\u2640\uFE0F','\u{1F3CA}\u200D\u2642\uFE0F','\u{1F3CA}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F3CA}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F3CA}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F3CA}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F3CA}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F3CA}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F3CA}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F3CA}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F3CA}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F3CA}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F3CB}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F3CB}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F3CB}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F3CB}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F3CB}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F3CB}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F3CB}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F3CB}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F3CB}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F3CB}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F3CB}\uFE0F\u200D\u2640\uFE0F','\u{1F3CB}\uFE0F\u200D\u2642\uFE0F','\u{1F3CC}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F3CC}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F3CC}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F3CC}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F3CC}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F3CC}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F3CC}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F3CC}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F3CC}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F3CC}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F3CC}\uFE0F\u200D\u2640\uFE0F','\u{1F3CC}\uFE0F\u200D\u2642\uFE0F','\u{1F46E}\u200D\u2640\uFE0F','\u{1F46E}\u200D\u2642\uFE0F','\u{1F46E}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F46E}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F46E}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F46E}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F46E}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F46E}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F46E}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F46E}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F46E}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F46E}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F46F}\u200D\u2640\uFE0F','\u{1F46F}\u200D\u2642\uFE0F','\u{1F46F}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F46F}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F46F}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F46F}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F46F}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F46F}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F46F}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F46F}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F46F}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F46F}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F470}\u200D\u2640\uFE0F','\u{1F470}\u200D\u2642\uFE0F','\u{1F470}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F470}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F470}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F470}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F470}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F470}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F470}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F470}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F470}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F470}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F471}\u200D\u2640\uFE0F','\u{1F471}\u200D\u2642\uFE0F','\u{1F471}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F471}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F471}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F471}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F471}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F471}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F471}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F471}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F471}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F471}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F473}\u200D\u2640\uFE0F','\u{1F473}\u200D\u2642\uFE0F','\u{1F473}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F473}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F473}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F473}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F473}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F473}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F473}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F473}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F473}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F473}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F477}\u200D\u2640\uFE0F','\u{1F477}\u200D\u2642\uFE0F','\u{1F477}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F477}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F477}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F477}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F477}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F477}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F477}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F477}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F477}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F477}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F481}\u200D\u2640\uFE0F','\u{1F481}\u200D\u2642\uFE0F','\u{1F481}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F481}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F481}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F481}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F481}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F481}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F481}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F481}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F481}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F481}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F482}\u200D\u2640\uFE0F','\u{1F482}\u200D\u2642\uFE0F','\u{1F482}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F482}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F482}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F482}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F482}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F482}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F482}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F482}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F482}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F482}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F486}\u200D\u2640\uFE0F','\u{1F486}\u200D\u2642\uFE0F','\u{1F486}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F486}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F486}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F486}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F486}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F486}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F486}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F486}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F486}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F486}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F487}\u200D\u2640\uFE0F','\u{1F487}\u200D\u2642\uFE0F','\u{1F487}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F487}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F487}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F487}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F487}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F487}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F487}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F487}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F487}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F487}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F575}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F575}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F575}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F575}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F575}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F575}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F575}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F575}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F575}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F575}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F575}\uFE0F\u200D\u2640\uFE0F','\u{1F575}\uFE0F\u200D\u2642\uFE0F','\u{1F645}\u200D\u2640\uFE0F','\u{1F645}\u200D\u2642\uFE0F','\u{1F645}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F645}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F645}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F645}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F645}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F645}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F645}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F645}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F645}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F645}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F646}\u200D\u2640\uFE0F','\u{1F646}\u200D\u2642\uFE0F','\u{1F646}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F646}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F646}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F646}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F646}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F646}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F646}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F646}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F646}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F646}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F647}\u200D\u2640\uFE0F','\u{1F647}\u200D\u2642\uFE0F','\u{1F647}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F647}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F647}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F647}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F647}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F647}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F647}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F647}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F647}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F647}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F64B}\u200D\u2640\uFE0F','\u{1F64B}\u200D\u2642\uFE0F','\u{1F64B}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F64B}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F64B}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F64B}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F64B}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F64B}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F64B}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F64B}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F64B}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F64B}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F64D}\u200D\u2640\uFE0F','\u{1F64D}\u200D\u2642\uFE0F','\u{1F64D}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F64D}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F64D}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F64D}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F64D}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F64D}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F64D}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F64D}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F64D}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F64D}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F64E}\u200D\u2640\uFE0F','\u{1F64E}\u200D\u2642\uFE0F','\u{1F64E}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F64E}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F64E}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F64E}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F64E}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F64E}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F64E}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F64E}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F64E}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F64E}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F6A3}\u200D\u2640\uFE0F','\u{1F6A3}\u200D\u2642\uFE0F','\u{1F6A3}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F6A3}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F6A3}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F6A3}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F6A3}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F6A3}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F6A3}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F6A3}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F6A3}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F6A3}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F6B4}\u200D\u2640\uFE0F','\u{1F6B4}\u200D\u2642\uFE0F','\u{1F6B4}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F6B4}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F6B4}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F6B4}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F6B4}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F6B4}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F6B4}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F6B4}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F6B4}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F6B4}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F6B5}\u200D\u2640\uFE0F','\u{1F6B5}\u200D\u2642\uFE0F','\u{1F6B5}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F6B5}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F6B5}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F6B5}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F6B5}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F6B5}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F6B5}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F6B5}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F6B5}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F6B5}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F6B6}\u200D\u2640\uFE0F','\u{1F6B6}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u200D\u2642\uFE0F','\u{1F6B6}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F6B6}\u{1F3FB}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F6B6}\u{1F3FB}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F6B6}\u{1F3FC}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F6B6}\u{1F3FC}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F6B6}\u{1F3FD}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F6B6}\u{1F3FD}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F6B6}\u{1F3FE}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F6B6}\u{1F3FE}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F6B6}\u{1F3FF}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F6B6}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F6B6}\u{1F3FF}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F926}\u200D\u2640\uFE0F','\u{1F926}\u200D\u2642\uFE0F','\u{1F926}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F926}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F926}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F926}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F926}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F926}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F926}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F926}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F926}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F926}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F935}\u200D\u2640\uFE0F','\u{1F935}\u200D\u2642\uFE0F','\u{1F935}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F935}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F935}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F935}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F935}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F935}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F935}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F935}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F935}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F935}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F937}\u200D\u2640\uFE0F','\u{1F937}\u200D\u2642\uFE0F','\u{1F937}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F937}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F937}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F937}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F937}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F937}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F937}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F937}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F937}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F937}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F938}\u200D\u2640\uFE0F','\u{1F938}\u200D\u2642\uFE0F','\u{1F938}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F938}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F938}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F938}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F938}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F938}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F938}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F938}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F938}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F938}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F939}\u200D\u2640\uFE0F','\u{1F939}\u200D\u2642\uFE0F','\u{1F939}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F939}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F939}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F939}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F939}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F939}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F939}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F939}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F939}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F939}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F93C}\u200D\u2640\uFE0F','\u{1F93C}\u200D\u2642\uFE0F','\u{1F93C}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F93C}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F93C}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F93C}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F93C}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F93C}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F93C}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F93C}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F93C}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F93C}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F93D}\u200D\u2640\uFE0F','\u{1F93D}\u200D\u2642\uFE0F','\u{1F93D}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F93D}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F93D}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F93D}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F93D}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F93D}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F93D}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F93D}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F93D}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F93D}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F93E}\u200D\u2640\uFE0F','\u{1F93E}\u200D\u2642\uFE0F','\u{1F93E}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F93E}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F93E}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F93E}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F93E}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F93E}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F93E}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F93E}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F93E}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F93E}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9B8}\u200D\u2640\uFE0F','\u{1F9B8}\u200D\u2642\uFE0F','\u{1F9B8}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9B8}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9B8}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9B8}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9B8}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9B8}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9B8}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9B8}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9B8}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9B8}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9B9}\u200D\u2640\uFE0F','\u{1F9B9}\u200D\u2642\uFE0F','\u{1F9B9}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9B9}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9B9}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9B9}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9B9}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9B9}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9B9}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9B9}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9B9}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9B9}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9CD}\u200D\u2640\uFE0F','\u{1F9CD}\u200D\u2642\uFE0F','\u{1F9CD}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9CD}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9CD}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9CD}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9CD}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9CD}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9CD}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9CD}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9CD}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9CD}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9CE}\u200D\u2640\uFE0F','\u{1F9CE}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u200D\u2642\uFE0F','\u{1F9CE}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9CE}\u{1F3FB}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9CE}\u{1F3FB}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9CE}\u{1F3FC}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9CE}\u{1F3FC}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9CE}\u{1F3FD}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9CE}\u{1F3FD}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9CE}\u{1F3FE}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9CE}\u{1F3FE}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9CE}\u{1F3FF}\u200D\u2640\uFE0F\u200D\u27A1\uFE0F','\u{1F9CE}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9CE}\u{1F3FF}\u200D\u2642\uFE0F\u200D\u27A1\uFE0F','\u{1F9CF}\u200D\u2640\uFE0F','\u{1F9CF}\u200D\u2642\uFE0F','\u{1F9CF}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9CF}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9CF}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9CF}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9CF}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9CF}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9CF}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9CF}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9CF}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9CF}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9D4}\u200D\u2640\uFE0F','\u{1F9D4}\u200D\u2642\uFE0F','\u{1F9D4}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9D4}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9D4}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9D4}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9D4}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9D4}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9D4}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9D4}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9D4}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9D4}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9D6}\u200D\u2640\uFE0F','\u{1F9D6}\u200D\u2642\uFE0F','\u{1F9D6}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9D6}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9D6}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9D6}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9D6}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9D6}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9D6}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9D6}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9D6}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9D6}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9D7}\u200D\u2640\uFE0F','\u{1F9D7}\u200D\u2642\uFE0F','\u{1F9D7}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9D7}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9D7}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9D7}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9D7}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9D7}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9D7}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9D7}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9D7}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9D7}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9D8}\u200D\u2640\uFE0F','\u{1F9D8}\u200D\u2642\uFE0F','\u{1F9D8}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9D8}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9D8}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9D8}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9D8}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9D8}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9D8}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9D8}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9D8}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9D8}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9D9}\u200D\u2640\uFE0F','\u{1F9D9}\u200D\u2642\uFE0F','\u{1F9D9}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9D9}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9D9}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9D9}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9D9}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9D9}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9D9}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9D9}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9D9}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9D9}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9DA}\u200D\u2640\uFE0F','\u{1F9DA}\u200D\u2642\uFE0F','\u{1F9DA}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9DA}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9DA}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9DA}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9DA}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9DA}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9DA}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9DA}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9DA}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9DA}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9DB}\u200D\u2640\uFE0F','\u{1F9DB}\u200D\u2642\uFE0F','\u{1F9DB}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9DB}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9DB}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9DB}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9DB}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9DB}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9DB}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9DB}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9DB}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9DB}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9DC}\u200D\u2640\uFE0F','\u{1F9DC}\u200D\u2642\uFE0F','\u{1F9DC}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9DC}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9DC}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9DC}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9DC}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9DC}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9DC}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9DC}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9DC}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9DC}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9DD}\u200D\u2640\uFE0F','\u{1F9DD}\u200D\u2642\uFE0F','\u{1F9DD}\u{1F3FB}\u200D\u2640\uFE0F','\u{1F9DD}\u{1F3FB}\u200D\u2642\uFE0F','\u{1F9DD}\u{1F3FC}\u200D\u2640\uFE0F','\u{1F9DD}\u{1F3FC}\u200D\u2642\uFE0F','\u{1F9DD}\u{1F3FD}\u200D\u2640\uFE0F','\u{1F9DD}\u{1F3FD}\u200D\u2642\uFE0F','\u{1F9DD}\u{1F3FE}\u200D\u2640\uFE0F','\u{1F9DD}\u{1F3FE}\u200D\u2642\uFE0F','\u{1F9DD}\u{1F3FF}\u200D\u2640\uFE0F','\u{1F9DD}\u{1F3FF}\u200D\u2642\uFE0F','\u{1F9DE}\u200D\u2640\uFE0F','\u{1F9DE}\u200D\u2642\uFE0F','\u{1F9DF}\u200D\u2640\uFE0F','\u{1F9DF}\u200D\u2642\uFE0F','\u{1F468}\u200D\u{1F9B0}','\u{1F468}\u200D\u{1F9B1}','\u{1F468}\u200D\u{1F9B2}','\u{1F468}\u200D\u{1F9B3}','\u{1F468}\u{1F3FB}\u200D\u{1F9B0}','\u{1F468}\u{1F3FB}\u200D\u{1F9B1}','\u{1F468}\u{1F3FB}\u200D\u{1F9B2}','\u{1F468}\u{1F3FB}\u200D\u{1F9B3}','\u{1F468}\u{1F3FC}\u200D\u{1F9B0}','\u{1F468}\u{1F3FC}\u200D\u{1F9B1}','\u{1F468}\u{1F3FC}\u200D\u{1F9B2}','\u{1F468}\u{1F3FC}\u200D\u{1F9B3}','\u{1F468}\u{1F3FD}\u200D\u{1F9B0}','\u{1F468}\u{1F3FD}\u200D\u{1F9B1}','\u{1F468}\u{1F3FD}\u200D\u{1F9B2}','\u{1F468}\u{1F3FD}\u200D\u{1F9B3}','\u{1F468}\u{1F3FE}\u200D\u{1F9B0}','\u{1F468}\u{1F3FE}\u200D\u{1F9B1}','\u{1F468}\u{1F3FE}\u200D\u{1F9B2}','\u{1F468}\u{1F3FE}\u200D\u{1F9B3}','\u{1F468}\u{1F3FF}\u200D\u{1F9B0}','\u{1F468}\u{1F3FF}\u200D\u{1F9B1}','\u{1F468}\u{1F3FF}\u200D\u{1F9B2}','\u{1F468}\u{1F3FF}\u200D\u{1F9B3}','\u{1F469}\u200D\u{1F9B0}','\u{1F469}\u200D\u{1F9B1}','\u{1F469}\u200D\u{1F9B2}','\u{1F469}\u200D\u{1F9B3}','\u{1F469}\u{1F3FB}\u200D\u{1F9B0}','\u{1F469}\u{1F3FB}\u200D\u{1F9B1}','\u{1F469}\u{1F3FB}\u200D\u{1F9B2}','\u{1F469}\u{1F3FB}\u200D\u{1F9B3}','\u{1F469}\u{1F3FC}\u200D\u{1F9B0}','\u{1F469}\u{1F3FC}\u200D\u{1F9B1}','\u{1F469}\u{1F3FC}\u200D\u{1F9B2}','\u{1F469}\u{1F3FC}\u200D\u{1F9B3}','\u{1F469}\u{1F3FD}\u200D\u{1F9B0}','\u{1F469}\u{1F3FD}\u200D\u{1F9B1}','\u{1F469}\u{1F3FD}\u200D\u{1F9B2}','\u{1F469}\u{1F3FD}\u200D\u{1F9B3}','\u{1F469}\u{1F3FE}\u200D\u{1F9B0}','\u{1F469}\u{1F3FE}\u200D\u{1F9B1}','\u{1F469}\u{1F3FE}\u200D\u{1F9B2}','\u{1F469}\u{1F3FE}\u200D\u{1F9B3}','\u{1F469}\u{1F3FF}\u200D\u{1F9B0}','\u{1F469}\u{1F3FF}\u200D\u{1F9B1}','\u{1F469}\u{1F3FF}\u200D\u{1F9B2}','\u{1F469}\u{1F3FF}\u200D\u{1F9B3}','\u{1F9D1}\u200D\u{1F9B0}','\u{1F9D1}\u200D\u{1F9B1}','\u{1F9D1}\u200D\u{1F9B2}','\u{1F9D1}\u200D\u{1F9B3}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9B0}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9B1}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9B2}','\u{1F9D1}\u{1F3FB}\u200D\u{1F9B3}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9B0}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9B1}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9B2}','\u{1F9D1}\u{1F3FC}\u200D\u{1F9B3}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9B0}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9B1}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9B2}','\u{1F9D1}\u{1F3FD}\u200D\u{1F9B3}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9B0}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9B1}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9B2}','\u{1F9D1}\u{1F3FE}\u200D\u{1F9B3}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9B0}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9B1}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9B2}','\u{1F9D1}\u{1F3FF}\u200D\u{1F9B3}','\u26D3\uFE0F\u200D\u{1F4A5}','\u2764\uFE0F\u200D\u{1F525}','\u2764\uFE0F\u200D\u{1FA79}','\u{1F344}\u200D\u{1F7EB}','\u{1F34B}\u200D\u{1F7E9}','\u{1F3F3}\uFE0F\u200D\u26A7\uFE0F','\u{1F3F3}\uFE0F\u200D\u{1F308}','\u{1F3F4}\u200D\u2620\uFE0F','\u{1F408}\u200D\u2B1B','\u{1F415}\u200D\u{1F9BA}','\u{1F426}\u200D\u2B1B','\u{1F426}\u200D\u{1F525}','\u{1F43B}\u200D\u2744\uFE0F','\u{1F441}\uFE0F\u200D\u{1F5E8}\uFE0F','\u{1F62E}\u200D\u{1F4A8}','\u{1F635}\u200D\u{1F4AB}','\u{1F636}\u200D\u{1F32B}\uFE0F','\u{1F642}\u200D\u2194\uFE0F','\u{1F642}\u200D\u2195\uFE0F','\u{1F9D1}\u200D\u{1FA70}','\u{1F9D1}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FB}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FB}\u200D\u{1FA70}','\u{1F9D1}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FB}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FC}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FC}\u200D\u{1FA70}','\u{1F9D1}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FC}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FD}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FD}\u200D\u{1FA70}','\u{1F9D1}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FD}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FE}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FE}\u200D\u{1FA70}','\u{1F9D1}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FE}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FF}','\u{1F9D1}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FF}\u200D\u{1F430}\u200D\u{1F9D1}\u{1F3FE}','\u{1F9D1}\u{1F3FF}\u200D\u{1FA70}','\u{1F9D1}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FB}','\u{1F9D1}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FC}','\u{1F9D1}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FD}','\u{1F9D1}\u{1F3FF}\u200D\u{1FAEF}\u200D\u{1F9D1}\u{1F3FE}']; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/README.md b/tools/ui/node_modules/regenerate-unicode-properties/README.md new file mode 100644 index 0000000000000000000000000000000000000000..392a75d2ef0b1ab243bd4a38c07f5985901882bd --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/README.md @@ -0,0 +1,70 @@ +# regenerate-unicode-properties [![regenerate-unicode-properties on npm](https://img.shields.io/npm/v/regenerate-unicode-properties)](https://www.npmjs.com/package/regenerate-unicode-properties) + +_regenerate-unicode-properties_ is a collection of [Regenerate](https://github.com/mathiasbynens/regenerate) sets for [various Unicode properties](https://github.com/tc39/proposal-regexp-unicode-property-escapes). + +## Installation + +To use _regenerate-unicode-properties_ programmatically, install it as a dependency via [npm](https://www.npmjs.com/): + +```bash +$ npm install regenerate-unicode-properties +``` + +## Usage + +To get a map of supported properties and their values: + +```js +const properties = require('regenerate-unicode-properties'); +``` + +To get a specific Regenerate set: + +```js +// Examples: +const Lu = require('regenerate-unicode-properties/General_Category/Uppercase_Letter.js').characters; +const Greek = require('regenerate-unicode-properties/Script_Extensions/Greek.js').characters; +``` + +Some properties can also refer to strings rather than single characters: +```js +const { characters, strings } = require('regenerate-unicode-properties/Property_of_Strings/Basic_Emoji.js'); +``` + +To get the Unicode version the data was based on: + +```js +const unicodeVersion = require('regenerate-unicode-properties/unicode-version.js'); +``` + +## For maintainers + +### How to publish a new release + +1. On the `main` branch, bump the version number in `package.json`: + + ```sh + npm version patch -m 'Release v%s' + ``` + + Instead of `patch`, use `minor` or `major` [as needed](https://semver.org/). + + Note that this produces a Git commit + tag. + +1. Push the release commit and tag: + + ```sh + git push && git push --tags + ``` + + Our CI then automatically publishes the new release to npm. + +## Author + +| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") | +|---| +| [Mathias Bynens](https://mathiasbynens.be/) | + +## License + +_regenerate-unicode-properties_ is available under the [MIT](https://mths.be/mit) license. diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Adlam.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Adlam.js new file mode 100644 index 0000000000000000000000000000000000000000..6838751328c833d7b06edb0ada938fc446b8dcbf --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Adlam.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1E900, 0x1E94B).addRange(0x1E950, 0x1E959).addRange(0x1E95E, 0x1E95F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Ahom.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Ahom.js new file mode 100644 index 0000000000000000000000000000000000000000..8d904d312292d257b8e2739f27503f94498cbc3d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Ahom.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11700, 0x1171A).addRange(0x1171D, 0x1172B).addRange(0x11730, 0x11746); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Anatolian_Hieroglyphs.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Anatolian_Hieroglyphs.js new file mode 100644 index 0000000000000000000000000000000000000000..9a2708580fb08e339512f967aff7a1e7a301ed1e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Anatolian_Hieroglyphs.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x14400, 0x14646); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Arabic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Arabic.js new file mode 100644 index 0000000000000000000000000000000000000000..ba6f03a638ffaae176b081139597de7db26698c5 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Arabic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E); +set.addRange(0x600, 0x604).addRange(0x606, 0x60B).addRange(0x60D, 0x61A).addRange(0x61C, 0x61E).addRange(0x620, 0x63F).addRange(0x641, 0x64A).addRange(0x656, 0x66F).addRange(0x671, 0x6DC).addRange(0x6DE, 0x6FF).addRange(0x750, 0x77F).addRange(0x870, 0x891).addRange(0x897, 0x8E1).addRange(0x8E3, 0x8FF).addRange(0xFB50, 0xFD3D).addRange(0xFD40, 0xFDCF).addRange(0xFDF0, 0xFDFF).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0x10E60, 0x10E7E).addRange(0x10EC2, 0x10EC7).addRange(0x10ED0, 0x10ED8).addRange(0x10EFA, 0x10EFF).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1EEF0, 0x1EEF1); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Armenian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Armenian.js new file mode 100644 index 0000000000000000000000000000000000000000..ef8b92298a913cb0ee178b97cdcc2e448c8f7b2b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Armenian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x531, 0x556).addRange(0x559, 0x58A).addRange(0x58D, 0x58F).addRange(0xFB13, 0xFB17); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Avestan.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Avestan.js new file mode 100644 index 0000000000000000000000000000000000000000..1be7d65fd99ea32e71147a4514f964fa5fca910e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Avestan.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10B00, 0x10B35).addRange(0x10B39, 0x10B3F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Balinese.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Balinese.js new file mode 100644 index 0000000000000000000000000000000000000000..90a395ea64f673a95857e0687cbad8685f8b5108 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Balinese.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1B00, 0x1B4C).addRange(0x1B4E, 0x1B7F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Bamum.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Bamum.js new file mode 100644 index 0000000000000000000000000000000000000000..10f96107c46223aa02d3a2dd3bf6348fe13de152 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Bamum.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA6A0, 0xA6F7).addRange(0x16800, 0x16A38); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Bassa_Vah.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Bassa_Vah.js new file mode 100644 index 0000000000000000000000000000000000000000..e98f574d023b2ce57ea0f08529bd66fcd2bf3359 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Bassa_Vah.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16AD0, 0x16AED).addRange(0x16AF0, 0x16AF5); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Batak.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Batak.js new file mode 100644 index 0000000000000000000000000000000000000000..8568f97b4dbc14fb4b6439c0252bfbca92cb9309 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Batak.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1BC0, 0x1BF3).addRange(0x1BFC, 0x1BFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Bengali.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Bengali.js new file mode 100644 index 0000000000000000000000000000000000000000..44846e893ecfcda08835c2587f2e77477e7c5b51 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Bengali.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x9B2, 0x9D7); +set.addRange(0x980, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BC, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CE).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E3).addRange(0x9E6, 0x9FE); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Beria_Erfe.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Beria_Erfe.js new file mode 100644 index 0000000000000000000000000000000000000000..9cdc4b0f5522161ce1593632af6a5abbb3a18b7b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Beria_Erfe.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Bhaiksuki.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Bhaiksuki.js new file mode 100644 index 0000000000000000000000000000000000000000..be0691819ab850e98c4e595bff911e4df98643ec --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Bhaiksuki.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C36).addRange(0x11C38, 0x11C45).addRange(0x11C50, 0x11C6C); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Bopomofo.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Bopomofo.js new file mode 100644 index 0000000000000000000000000000000000000000..3e0c2d8d68186a361c60b4868cd71104ae2c9167 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Bopomofo.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x2EA, 0x2EB).addRange(0x3105, 0x312F).addRange(0x31A0, 0x31BF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Brahmi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Brahmi.js new file mode 100644 index 0000000000000000000000000000000000000000..9d104df65a0ce0b11c4fdaaa151b8c6a45a965cb --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Brahmi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1107F); +set.addRange(0x11000, 0x1104D).addRange(0x11052, 0x11075); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Braille.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Braille.js new file mode 100644 index 0000000000000000000000000000000000000000..4b6b88fddac828bec3c386872d4f4fdb3225c55e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Braille.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x2800, 0x28FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Buginese.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Buginese.js new file mode 100644 index 0000000000000000000000000000000000000000..c9d001fcdbd1aef557c6f49986341b19dd5305d8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Buginese.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1A00, 0x1A1B).addRange(0x1A1E, 0x1A1F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Buhid.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Buhid.js new file mode 100644 index 0000000000000000000000000000000000000000..d59d3d126aaf3158934fbe7afa75d9b2f363cf70 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Buhid.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1740, 0x1753); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Canadian_Aboriginal.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Canadian_Aboriginal.js new file mode 100644 index 0000000000000000000000000000000000000000..d601f89aced9f2b78f8f8c5ff54c70fe45054553 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Canadian_Aboriginal.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1400, 0x167F).addRange(0x18B0, 0x18F5).addRange(0x11AB0, 0x11ABF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Carian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Carian.js new file mode 100644 index 0000000000000000000000000000000000000000..2777f50ba889983cbe7ea794cb01d63499ba6af8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Carian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x102A0, 0x102D0); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Caucasian_Albanian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Caucasian_Albanian.js new file mode 100644 index 0000000000000000000000000000000000000000..fac9b63d4962d589bdbaa8a823f2efcd7fabf0d8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Caucasian_Albanian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1056F); +set.addRange(0x10530, 0x10563); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Chakma.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Chakma.js new file mode 100644 index 0000000000000000000000000000000000000000..c2cbad387d8a38c14383bc13956f84d69234c111 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Chakma.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11100, 0x11134).addRange(0x11136, 0x11147); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Cham.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Cham.js new file mode 100644 index 0000000000000000000000000000000000000000..6d5304bb6b8fccea848c68a690f43e83c400ddac --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Cham.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xAA00, 0xAA36).addRange(0xAA40, 0xAA4D).addRange(0xAA50, 0xAA59).addRange(0xAA5C, 0xAA5F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Cherokee.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Cherokee.js new file mode 100644 index 0000000000000000000000000000000000000000..992ef27e7b8167a25bbe4686c2102ebc48b25f03 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Cherokee.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0xAB70, 0xABBF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Chorasmian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Chorasmian.js new file mode 100644 index 0000000000000000000000000000000000000000..5d56367bdc69d555a7ca00e381bf0773a89e7752 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Chorasmian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10FB0, 0x10FCB); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Common.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Common.js new file mode 100644 index 0000000000000000000000000000000000000000..094449302557e86e0ceec180c6b6e59da7f4ea8c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Common.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0xD7, 0xF7, 0x374, 0x37E, 0x385, 0x387, 0x605, 0x60C, 0x61B, 0x61F, 0x640, 0x6DD, 0x8E2, 0xE3F, 0x10FB, 0x1805, 0x1CD3, 0x1CE1, 0x1CFA, 0x3006, 0x30A0, 0x31EF, 0x32FF, 0xA92E, 0xA9CF, 0xAB5B, 0xFEFF, 0xFF70, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1F7F0, 0x1FAC8, 0xE0001); +set.addRange(0x0, 0x40).addRange(0x5B, 0x60).addRange(0x7B, 0xA9).addRange(0xAB, 0xB9).addRange(0xBB, 0xBF).addRange(0x2B9, 0x2DF).addRange(0x2E5, 0x2E9).addRange(0x2EC, 0x2FF).addRange(0x964, 0x965).addRange(0xFD5, 0xFD8).addRange(0x16EB, 0x16ED).addRange(0x1735, 0x1736).addRange(0x1802, 0x1803).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF7).addRange(0x2000, 0x200B).addRange(0x200E, 0x2064).addRange(0x2066, 0x2070).addRange(0x2074, 0x207E).addRange(0x2080, 0x208E).addRange(0x20A0, 0x20C1).addRange(0x2100, 0x2125).addRange(0x2127, 0x2129).addRange(0x212C, 0x2131).addRange(0x2133, 0x214D).addRange(0x214F, 0x215F).addRange(0x2189, 0x218B).addRange(0x2190, 0x2429).addRange(0x2440, 0x244A).addRange(0x2460, 0x27FF).addRange(0x2900, 0x2B73).addRange(0x2B76, 0x2BFF).addRange(0x2E00, 0x2E5D).addRange(0x2FF0, 0x3004).addRange(0x3008, 0x3020).addRange(0x3030, 0x3037).addRange(0x303C, 0x303F).addRange(0x309B, 0x309C).addRange(0x30FB, 0x30FC).addRange(0x3190, 0x319F).addRange(0x31C0, 0x31E5).addRange(0x3220, 0x325F).addRange(0x327F, 0x32CF).addRange(0x3358, 0x33FF).addRange(0x4DC0, 0x4DFF).addRange(0xA700, 0xA721).addRange(0xA788, 0xA78A).addRange(0xA830, 0xA839).addRange(0xAB6A, 0xAB6B).addRange(0xFD3E, 0xFD3F); +set.addRange(0xFE10, 0xFE19).addRange(0xFE30, 0xFE52).addRange(0xFE54, 0xFE66).addRange(0xFE68, 0xFE6B).addRange(0xFF01, 0xFF20).addRange(0xFF3B, 0xFF40).addRange(0xFF5B, 0xFF65).addRange(0xFF9E, 0xFF9F).addRange(0xFFE0, 0xFFE6).addRange(0xFFE8, 0xFFEE).addRange(0xFFF9, 0xFFFD).addRange(0x10100, 0x10102).addRange(0x10107, 0x10133).addRange(0x10137, 0x1013F).addRange(0x10190, 0x1019C).addRange(0x101D0, 0x101FC).addRange(0x102E1, 0x102FB).addRange(0x1BCA0, 0x1BCA3).addRange(0x1CC00, 0x1CCFC).addRange(0x1CD00, 0x1CEB3).addRange(0x1CEBA, 0x1CED0).addRange(0x1CEE0, 0x1CEF0).addRange(0x1CF50, 0x1CFC3).addRange(0x1D000, 0x1D0F5).addRange(0x1D100, 0x1D126).addRange(0x1D129, 0x1D166).addRange(0x1D16A, 0x1D17A).addRange(0x1D183, 0x1D184).addRange(0x1D18C, 0x1D1A9).addRange(0x1D1AE, 0x1D1EA).addRange(0x1D2C0, 0x1D2D3).addRange(0x1D2E0, 0x1D2F3).addRange(0x1D300, 0x1D356).addRange(0x1D360, 0x1D378).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D7CB); +set.addRange(0x1D7CE, 0x1D7FF).addRange(0x1EC71, 0x1ECB4).addRange(0x1ED01, 0x1ED3D).addRange(0x1F000, 0x1F02B).addRange(0x1F030, 0x1F093).addRange(0x1F0A0, 0x1F0AE).addRange(0x1F0B1, 0x1F0BF).addRange(0x1F0C1, 0x1F0CF).addRange(0x1F0D1, 0x1F0F5).addRange(0x1F100, 0x1F1AD).addRange(0x1F1E6, 0x1F1FF).addRange(0x1F201, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F250, 0x1F251).addRange(0x1F260, 0x1F265).addRange(0x1F300, 0x1F6D8).addRange(0x1F6DC, 0x1F6EC).addRange(0x1F6F0, 0x1F6FC).addRange(0x1F700, 0x1F7D9).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F800, 0x1F80B).addRange(0x1F810, 0x1F847).addRange(0x1F850, 0x1F859).addRange(0x1F860, 0x1F887).addRange(0x1F890, 0x1F8AD).addRange(0x1F8B0, 0x1F8BB).addRange(0x1F8C0, 0x1F8C1).addRange(0x1F8D0, 0x1F8D8).addRange(0x1F900, 0x1FA57).addRange(0x1FA60, 0x1FA6D).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA8A).addRange(0x1FA8E, 0x1FAC6).addRange(0x1FACD, 0x1FADC).addRange(0x1FADF, 0x1FAEA).addRange(0x1FAEF, 0x1FAF8).addRange(0x1FB00, 0x1FB92).addRange(0x1FB94, 0x1FBFA).addRange(0xE0020, 0xE007F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Coptic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Coptic.js new file mode 100644 index 0000000000000000000000000000000000000000..c4b08cafc7cfb5e2b34cdb9736cbae5f89bc4c92 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Coptic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x3E2, 0x3EF).addRange(0x2C80, 0x2CF3).addRange(0x2CF9, 0x2CFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Cuneiform.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Cuneiform.js new file mode 100644 index 0000000000000000000000000000000000000000..1d4da572254e5734c189bdbc504510c81053c708 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Cuneiform.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12470, 0x12474).addRange(0x12480, 0x12543); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Cypriot.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Cypriot.js new file mode 100644 index 0000000000000000000000000000000000000000..5b1a125fcabf08e8b14e0201a4ca9a0b7034bb03 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Cypriot.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x10808, 0x1083C, 0x1083F); +set.addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Cypro_Minoan.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Cypro_Minoan.js new file mode 100644 index 0000000000000000000000000000000000000000..99371b376f384457bfb1bbb18efcdc8147902f18 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Cypro_Minoan.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x12F90, 0x12FF2); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Cyrillic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Cyrillic.js new file mode 100644 index 0000000000000000000000000000000000000000..c48c82a47cf8c2b3cafe842a0f913c3db3c35fda --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Cyrillic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1D2B, 0x1D78, 0x1E08F); +set.addRange(0x400, 0x484).addRange(0x487, 0x52F).addRange(0x1C80, 0x1C8A).addRange(0x2DE0, 0x2DFF).addRange(0xA640, 0xA69F).addRange(0xFE2E, 0xFE2F).addRange(0x1E030, 0x1E06D); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Deseret.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Deseret.js new file mode 100644 index 0000000000000000000000000000000000000000..068648351317f8d65b3d397e0217bd6a16da1221 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Deseret.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10400, 0x1044F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Devanagari.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Devanagari.js new file mode 100644 index 0000000000000000000000000000000000000000..0448ebb0ca84fc7b2ef744572935906963b94191 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Devanagari.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x900, 0x950).addRange(0x955, 0x963).addRange(0x966, 0x97F).addRange(0xA8E0, 0xA8FF).addRange(0x11B00, 0x11B09); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Dives_Akuru.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Dives_Akuru.js new file mode 100644 index 0000000000000000000000000000000000000000..242d20a32def11bd2ffbf9589939f16111a30269 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Dives_Akuru.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x11909); +set.addRange(0x11900, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x11946).addRange(0x11950, 0x11959); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Dogra.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Dogra.js new file mode 100644 index 0000000000000000000000000000000000000000..5722f2ebcb736e1a7ce4fa09d5ee7074649f3213 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Dogra.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11800, 0x1183B); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Duployan.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Duployan.js new file mode 100644 index 0000000000000000000000000000000000000000..dbc990da4e52752ea09571da32b2b3f508007a71 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Duployan.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1BC9C, 0x1BC9F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Egyptian_Hieroglyphs.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Egyptian_Hieroglyphs.js new file mode 100644 index 0000000000000000000000000000000000000000..e2fcdc8000e18221c4e1736f5ba3f71e3285c60b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Egyptian_Hieroglyphs.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x13000, 0x13455).addRange(0x13460, 0x143FA); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Elbasan.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Elbasan.js new file mode 100644 index 0000000000000000000000000000000000000000..ba7a16d24a13b4485b45c105661b13ca3de51d74 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Elbasan.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10500, 0x10527); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Elymaic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Elymaic.js new file mode 100644 index 0000000000000000000000000000000000000000..1481d0b47a69308c337517fd6e2209470bd7ab40 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Elymaic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10FE0, 0x10FF6); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Ethiopic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Ethiopic.js new file mode 100644 index 0000000000000000000000000000000000000000..46d0c32a901c6c00874c75d71a218d26393d7d40 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Ethiopic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1258, 0x12C0); +set.addRange(0x1200, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x135D, 0x137C).addRange(0x1380, 0x1399).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Garay.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Garay.js new file mode 100644 index 0000000000000000000000000000000000000000..cd2a472c004e68585513c97278044db5da41eafc --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Garay.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10D40, 0x10D65).addRange(0x10D69, 0x10D85).addRange(0x10D8E, 0x10D8F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Georgian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Georgian.js new file mode 100644 index 0000000000000000000000000000000000000000..b00102d11e17d9fe3c6feb6ad3b79d05b4d33f32 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Georgian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x10C7, 0x10CD, 0x2D27, 0x2D2D); +set.addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x10FF).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x2D00, 0x2D25); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Glagolitic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Glagolitic.js new file mode 100644 index 0000000000000000000000000000000000000000..c70402e5b359a56fba1ae92613d841a9396f8aaa --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Glagolitic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x2C00, 0x2C5F).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Gothic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Gothic.js new file mode 100644 index 0000000000000000000000000000000000000000..784eb78ee5d47f06ae3a615ba409f206a2408342 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Gothic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10330, 0x1034A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Grantha.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Grantha.js new file mode 100644 index 0000000000000000000000000000000000000000..be32eb12eee05c30bffd73b2b29f17a60059d7bf --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Grantha.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x11350, 0x11357); +set.addRange(0x11300, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1133C, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x1135D, 0x11363).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Greek.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Greek.js new file mode 100644 index 0000000000000000000000000000000000000000..f8912e50cd775cc30c03146fc4e9f894db1f26b3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Greek.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x37F, 0x384, 0x386, 0x38C, 0x1DBF, 0x1F59, 0x1F5B, 0x1F5D, 0x2126, 0xAB65, 0x101A0); +set.addRange(0x370, 0x373).addRange(0x375, 0x377).addRange(0x37A, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3E1).addRange(0x3F0, 0x3FF).addRange(0x1D26, 0x1D2A).addRange(0x1D5D, 0x1D61).addRange(0x1D66, 0x1D6A).addRange(0x1F00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FC4).addRange(0x1FC6, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FDD, 0x1FEF).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFE).addRange(0x10140, 0x1018E).addRange(0x1D200, 0x1D245); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Gujarati.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Gujarati.js new file mode 100644 index 0000000000000000000000000000000000000000..7c29fc56df1f4044aa9e26da833bb6e4dec3cb43 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Gujarati.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xAD0); +set.addRange(0xA81, 0xA83).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABC, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACD).addRange(0xAE0, 0xAE3).addRange(0xAE6, 0xAF1).addRange(0xAF9, 0xAFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Gunjala_Gondi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Gunjala_Gondi.js new file mode 100644 index 0000000000000000000000000000000000000000..e7edf6dae5ace1e26a4913220b0df07f682371db --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Gunjala_Gondi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D98).addRange(0x11DA0, 0x11DA9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Gurmukhi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Gurmukhi.js new file mode 100644 index 0000000000000000000000000000000000000000..9ae816c803e9844fac64d13a502213acfab834ec --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Gurmukhi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xA3C, 0xA51, 0xA5E); +set.addRange(0xA01, 0xA03).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA59, 0xA5C).addRange(0xA66, 0xA76); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Gurung_Khema.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Gurung_Khema.js new file mode 100644 index 0000000000000000000000000000000000000000..ef7b807a7b4787824f6c700a79fda3202ecffdb9 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Gurung_Khema.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16100, 0x16139); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Han.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Han.js new file mode 100644 index 0000000000000000000000000000000000000000..17d946161e2d2e0c32a5116741ab8ea14382c237 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Han.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x3005, 0x3007); +set.addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5).addRange(0x3021, 0x3029).addRange(0x3038, 0x303B).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0x9FFF).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0x16FE2, 0x16FE3).addRange(0x16FF0, 0x16FF6).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Hangul.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Hangul.js new file mode 100644 index 0000000000000000000000000000000000000000..c0cd243b57b71875c58b40cdafb0a9b1f5d3456c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Hangul.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1100, 0x11FF).addRange(0x302E, 0x302F).addRange(0x3131, 0x318E).addRange(0x3200, 0x321E).addRange(0x3260, 0x327E).addRange(0xA960, 0xA97C).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xFFA0, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Hanifi_Rohingya.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Hanifi_Rohingya.js new file mode 100644 index 0000000000000000000000000000000000000000..f9a76aa7d27cf6c71eca45b56ee51d1d2610b55b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Hanifi_Rohingya.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10D00, 0x10D27).addRange(0x10D30, 0x10D39); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Hanunoo.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Hanunoo.js new file mode 100644 index 0000000000000000000000000000000000000000..b68dd1ee4d5e7d61b90f155fb949ee620247d143 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Hanunoo.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1720, 0x1734); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Hatran.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Hatran.js new file mode 100644 index 0000000000000000000000000000000000000000..2a21cfde04686a091587cc949d1fc2400e4a2023 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Hatran.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x108FB, 0x108FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Hebrew.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Hebrew.js new file mode 100644 index 0000000000000000000000000000000000000000..3d46e0ec6a97bb534293cfdcff8eb47f95fbb8f5 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Hebrew.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xFB3E); +set.addRange(0x591, 0x5C7).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F4).addRange(0xFB1D, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFB4F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Hiragana.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Hiragana.js new file mode 100644 index 0000000000000000000000000000000000000000..1a71f7575a8e2bc09c84c60bba4809ec52a3e694 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Hiragana.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1B132, 0x1F200); +set.addRange(0x3041, 0x3096).addRange(0x309D, 0x309F).addRange(0x1B001, 0x1B11F).addRange(0x1B150, 0x1B152); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Imperial_Aramaic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Imperial_Aramaic.js new file mode 100644 index 0000000000000000000000000000000000000000..eb30687960acb069695a2424be96fd8608b324d3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Imperial_Aramaic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10840, 0x10855).addRange(0x10857, 0x1085F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Inherited.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Inherited.js new file mode 100644 index 0000000000000000000000000000000000000000..df82f1a3d960b853b0ed658af1afb36abb34e600 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Inherited.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x670, 0x1CED, 0x1CF4, 0x101FD, 0x102E0, 0x1133B); +set.addRange(0x300, 0x36F).addRange(0x485, 0x486).addRange(0x64B, 0x655).addRange(0x951, 0x954).addRange(0x1AB0, 0x1ADD).addRange(0x1AE0, 0x1AEB).addRange(0x1CD0, 0x1CD2).addRange(0x1CD4, 0x1CE0).addRange(0x1CE2, 0x1CE8).addRange(0x1CF8, 0x1CF9).addRange(0x1DC0, 0x1DFF).addRange(0x200C, 0x200D).addRange(0x20D0, 0x20F0).addRange(0x302A, 0x302D).addRange(0x3099, 0x309A).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2D).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D167, 0x1D169).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0xE0100, 0xE01EF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Inscriptional_Pahlavi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Inscriptional_Pahlavi.js new file mode 100644 index 0000000000000000000000000000000000000000..ae7dd10d16d0441d48aad8389b85fe3a5a5e0552 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Inscriptional_Pahlavi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10B60, 0x10B72).addRange(0x10B78, 0x10B7F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Inscriptional_Parthian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Inscriptional_Parthian.js new file mode 100644 index 0000000000000000000000000000000000000000..decc12d8d31ee38485036523bec22e712b101fe3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Inscriptional_Parthian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10B40, 0x10B55).addRange(0x10B58, 0x10B5F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Javanese.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Javanese.js new file mode 100644 index 0000000000000000000000000000000000000000..541d94dbaa9742fefc9846a56179c2a496ee5f70 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Javanese.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA980, 0xA9CD).addRange(0xA9D0, 0xA9D9).addRange(0xA9DE, 0xA9DF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Kaithi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Kaithi.js new file mode 100644 index 0000000000000000000000000000000000000000..fdfa58679249736343821eb5405743a86e02f415 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Kaithi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x110CD); +set.addRange(0x11080, 0x110C2); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Kannada.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Kannada.js new file mode 100644 index 0000000000000000000000000000000000000000..8ee9ba5712ec436ebc1102d8756245a97448dc29 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Kannada.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xC80, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCBC, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCDC, 0xCDE).addRange(0xCE0, 0xCE3).addRange(0xCE6, 0xCEF).addRange(0xCF1, 0xCF3); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Katakana.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Katakana.js new file mode 100644 index 0000000000000000000000000000000000000000..d55ac1bc06f2786d46b7f7456c85998d00fcb55c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Katakana.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1B000, 0x1B155); +set.addRange(0x30A1, 0x30FA).addRange(0x30FD, 0x30FF).addRange(0x31F0, 0x31FF).addRange(0x32D0, 0x32FE).addRange(0x3300, 0x3357).addRange(0xFF66, 0xFF6F).addRange(0xFF71, 0xFF9D).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B120, 0x1B122).addRange(0x1B164, 0x1B167); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Kawi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Kawi.js new file mode 100644 index 0000000000000000000000000000000000000000..c306305d0071c279dd1dc278fbe9f481b2aa918c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Kawi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11F00, 0x11F10).addRange(0x11F12, 0x11F3A).addRange(0x11F3E, 0x11F5A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Kayah_Li.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Kayah_Li.js new file mode 100644 index 0000000000000000000000000000000000000000..649690a49a53f2dea8f920977cb143fd55f901a2 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Kayah_Li.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xA92F); +set.addRange(0xA900, 0xA92D); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Kharoshthi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Kharoshthi.js new file mode 100644 index 0000000000000000000000000000000000000000..10f07e4b7c91a55739fc56b408370a09632a7f34 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Kharoshthi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10A00, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A38, 0x10A3A).addRange(0x10A3F, 0x10A48).addRange(0x10A50, 0x10A58); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Khitan_Small_Script.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Khitan_Small_Script.js new file mode 100644 index 0000000000000000000000000000000000000000..fda2548cd94c5524b4de6eacc714534001b6487c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Khitan_Small_Script.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x16FE4, 0x18CFF); +set.addRange(0x18B00, 0x18CD5); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Khmer.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Khmer.js new file mode 100644 index 0000000000000000000000000000000000000000..e15f4e3cc8d92a44dd189ce617855998bdacc4ec --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Khmer.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1780, 0x17DD).addRange(0x17E0, 0x17E9).addRange(0x17F0, 0x17F9).addRange(0x19E0, 0x19FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Khojki.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Khojki.js new file mode 100644 index 0000000000000000000000000000000000000000..819c99e237ce77b46ce4e311aa1fd09d37179076 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Khojki.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11200, 0x11211).addRange(0x11213, 0x11241); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Khudawadi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Khudawadi.js new file mode 100644 index 0000000000000000000000000000000000000000..32080ee43356dee901836ddc24cd7a2f228ac8d8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Khudawadi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x112B0, 0x112EA).addRange(0x112F0, 0x112F9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Kirat_Rai.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Kirat_Rai.js new file mode 100644 index 0000000000000000000000000000000000000000..261dcd253dadefd1dfeb9089a83c8472b64ef2b8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Kirat_Rai.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16D40, 0x16D79); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Lao.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Lao.js new file mode 100644 index 0000000000000000000000000000000000000000..7b4a7d94dcbc8bb091105e9c84e07a09e92e66d9 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Lao.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xE84, 0xEA5, 0xEC6); +set.addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEBD).addRange(0xEC0, 0xEC4).addRange(0xEC8, 0xECE).addRange(0xED0, 0xED9).addRange(0xEDC, 0xEDF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Latin.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Latin.js new file mode 100644 index 0000000000000000000000000000000000000000..212315e72f6e60fe3c8aacedf41001b72067c075 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Latin.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xAA, 0xBA, 0x2071, 0x207F, 0x2132, 0x214E); +set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2B8).addRange(0x2E0, 0x2E4).addRange(0x1D00, 0x1D25).addRange(0x1D2C, 0x1D5C).addRange(0x1D62, 0x1D65).addRange(0x1D6B, 0x1D77).addRange(0x1D79, 0x1DBE).addRange(0x1E00, 0x1EFF).addRange(0x2090, 0x209C).addRange(0x212A, 0x212B).addRange(0x2160, 0x2188).addRange(0x2C60, 0x2C7F).addRange(0xA722, 0xA787).addRange(0xA78B, 0xA7DC).addRange(0xA7F1, 0xA7FF).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB64).addRange(0xAB66, 0xAB69).addRange(0xFB00, 0xFB06).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Lepcha.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Lepcha.js new file mode 100644 index 0000000000000000000000000000000000000000..3a495e6666578f0c65b6e3fc20f0ed28bf9b1f07 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Lepcha.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1C00, 0x1C37).addRange(0x1C3B, 0x1C49).addRange(0x1C4D, 0x1C4F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Limbu.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Limbu.js new file mode 100644 index 0000000000000000000000000000000000000000..8512f0ef89209ba56fe774acc8d0600f2e9bb793 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Limbu.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1940); +set.addRange(0x1900, 0x191E).addRange(0x1920, 0x192B).addRange(0x1930, 0x193B).addRange(0x1944, 0x194F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Linear_A.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Linear_A.js new file mode 100644 index 0000000000000000000000000000000000000000..cee454352e962da3e0d4e2ad0d50b2b8369fe646 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Linear_A.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Linear_B.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Linear_B.js new file mode 100644 index 0000000000000000000000000000000000000000..c18cac3e8295c202f18e160dae12cf9649d71824 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Linear_B.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Lisu.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Lisu.js new file mode 100644 index 0000000000000000000000000000000000000000..4e91f68e380fd1ea74cbca452498a12ccc0aa263 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Lisu.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x11FB0); +set.addRange(0xA4D0, 0xA4FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Lycian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Lycian.js new file mode 100644 index 0000000000000000000000000000000000000000..eb1cc7dbb232a485e6c0cf1c614f7744a883cca4 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Lycian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10280, 0x1029C); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Lydian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Lydian.js new file mode 100644 index 0000000000000000000000000000000000000000..1abc731670057401ad5f8058e2a37660b0209a33 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Lydian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1093F); +set.addRange(0x10920, 0x10939); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Mahajani.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Mahajani.js new file mode 100644 index 0000000000000000000000000000000000000000..22e870292c1ec998d64662ad4eceb65bd9b583cd --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Mahajani.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11150, 0x11176); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Makasar.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Makasar.js new file mode 100644 index 0000000000000000000000000000000000000000..498a157caefbf4bd385fdca670339b2d6cb06a3f --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Makasar.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11EE0, 0x11EF8); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Malayalam.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Malayalam.js new file mode 100644 index 0000000000000000000000000000000000000000..04e730430f2f22d747b1cbf52f30256abfdecb5e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Malayalam.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xD00, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4F).addRange(0xD54, 0xD63).addRange(0xD66, 0xD7F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Mandaic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Mandaic.js new file mode 100644 index 0000000000000000000000000000000000000000..1c4661af9509d6fb92021d8fb2317fb621052201 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Mandaic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x85E); +set.addRange(0x840, 0x85B); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Manichaean.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Manichaean.js new file mode 100644 index 0000000000000000000000000000000000000000..0377c27b92a826b629faf29c63b2cd82a40e13b8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Manichaean.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10AC0, 0x10AE6).addRange(0x10AEB, 0x10AF6); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Marchen.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Marchen.js new file mode 100644 index 0000000000000000000000000000000000000000..08b94ce4e9bc21a49028efc8721f0dec190f00bd --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Marchen.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11C70, 0x11C8F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Masaram_Gondi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Masaram_Gondi.js new file mode 100644 index 0000000000000000000000000000000000000000..8a27645a7701d0542009c9079dba1716cc68bf53 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Masaram_Gondi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x11D3A); +set.addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D47).addRange(0x11D50, 0x11D59); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Medefaidrin.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Medefaidrin.js new file mode 100644 index 0000000000000000000000000000000000000000..d99281c2ad7eccb0dd9da4ccd69be3c52fe7cba6 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Medefaidrin.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16E40, 0x16E9A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Meetei_Mayek.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Meetei_Mayek.js new file mode 100644 index 0000000000000000000000000000000000000000..247ad69801134341b576d9253428416290baa852 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Meetei_Mayek.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xAAE0, 0xAAF6).addRange(0xABC0, 0xABED).addRange(0xABF0, 0xABF9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Mende_Kikakui.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Mende_Kikakui.js new file mode 100644 index 0000000000000000000000000000000000000000..a451df7986d68a439ffbfe8c62da0d4753f0dba9 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Mende_Kikakui.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1E800, 0x1E8C4).addRange(0x1E8C7, 0x1E8D6); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Meroitic_Cursive.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Meroitic_Cursive.js new file mode 100644 index 0000000000000000000000000000000000000000..e885fe749d410b6fbe0c87a09331abd3f8eb5820 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Meroitic_Cursive.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x109A0, 0x109B7).addRange(0x109BC, 0x109CF).addRange(0x109D2, 0x109FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Meroitic_Hieroglyphs.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Meroitic_Hieroglyphs.js new file mode 100644 index 0000000000000000000000000000000000000000..8804e91b14d62b0ab1b5dd0a6d4d29ef8d2fbd39 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Meroitic_Hieroglyphs.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10980, 0x1099F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Miao.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Miao.js new file mode 100644 index 0000000000000000000000000000000000000000..d6fba56e72148c5b032d30909c5bd140bb5af4e0 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Miao.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16F00, 0x16F4A).addRange(0x16F4F, 0x16F87).addRange(0x16F8F, 0x16F9F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Modi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Modi.js new file mode 100644 index 0000000000000000000000000000000000000000..0cbf216963990a49377fa342ea22705bcb448a51 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Modi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11600, 0x11644).addRange(0x11650, 0x11659); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Mongolian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Mongolian.js new file mode 100644 index 0000000000000000000000000000000000000000..fe419edb12ce9d7ffade0f0ac3578630fb380e1b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Mongolian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1804); +set.addRange(0x1800, 0x1801).addRange(0x1806, 0x1819).addRange(0x1820, 0x1878).addRange(0x1880, 0x18AA).addRange(0x11660, 0x1166C); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Mro.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Mro.js new file mode 100644 index 0000000000000000000000000000000000000000..4789836987030754d3a2f519a2f72d1f55134a1e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Mro.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16A40, 0x16A5E).addRange(0x16A60, 0x16A69).addRange(0x16A6E, 0x16A6F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Multani.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Multani.js new file mode 100644 index 0000000000000000000000000000000000000000..dcc6dd753b1d196ce3a8f04e4cf2215e8ab2d838 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Multani.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x11288); +set.addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Myanmar.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Myanmar.js new file mode 100644 index 0000000000000000000000000000000000000000..3295c15aeb6ccebedaa61ec742a05bda223e3046 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Myanmar.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1000, 0x109F).addRange(0xA9E0, 0xA9FE).addRange(0xAA60, 0xAA7F).addRange(0x116D0, 0x116E3); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Nabataean.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Nabataean.js new file mode 100644 index 0000000000000000000000000000000000000000..5aed2692d0de876d09779f1f5aeefe3b5f314a8d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Nabataean.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10880, 0x1089E).addRange(0x108A7, 0x108AF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Nag_Mundari.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Nag_Mundari.js new file mode 100644 index 0000000000000000000000000000000000000000..1e32d9ac5970eddf68971bf9db0d905dec6e2ece --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Nag_Mundari.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1E4D0, 0x1E4F9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Nandinagari.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Nandinagari.js new file mode 100644 index 0000000000000000000000000000000000000000..b9c98baa4b31362d3bd518cf1340678bf1a9b5b1 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Nandinagari.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D7).addRange(0x119DA, 0x119E4); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/New_Tai_Lue.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/New_Tai_Lue.js new file mode 100644 index 0000000000000000000000000000000000000000..27e20dc4c59cbc9d871379f6e310ef5bdea05ffb --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/New_Tai_Lue.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x19D0, 0x19DA).addRange(0x19DE, 0x19DF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Newa.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Newa.js new file mode 100644 index 0000000000000000000000000000000000000000..11134589897515a8dbdd78e020b946fcf0bbafaa --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Newa.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11400, 0x1145B).addRange(0x1145D, 0x11461); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Nko.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Nko.js new file mode 100644 index 0000000000000000000000000000000000000000..12d17f97bcb6ce146cd723d6e760b69f11f2031d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Nko.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x7C0, 0x7FA).addRange(0x7FD, 0x7FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Nushu.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Nushu.js new file mode 100644 index 0000000000000000000000000000000000000000..4183de5ffc85999c66ad23cbcce4690c3e1cdea0 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Nushu.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x16FE1); +set.addRange(0x1B170, 0x1B2FB); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Nyiakeng_Puachue_Hmong.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Nyiakeng_Puachue_Hmong.js new file mode 100644 index 0000000000000000000000000000000000000000..dcf75e7d33ce36e270548bb321e592437934d375 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Nyiakeng_Puachue_Hmong.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1E100, 0x1E12C).addRange(0x1E130, 0x1E13D).addRange(0x1E140, 0x1E149).addRange(0x1E14E, 0x1E14F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Ogham.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Ogham.js new file mode 100644 index 0000000000000000000000000000000000000000..899a9f78a761d9ea626860c3ed9daf1bfb62c27e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Ogham.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1680, 0x169C); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Ol_Chiki.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Ol_Chiki.js new file mode 100644 index 0000000000000000000000000000000000000000..73e64c3e64f795e3416ffea6a34679228d8e14f8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Ol_Chiki.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1C50, 0x1C7F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Ol_Onal.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Ol_Onal.js new file mode 100644 index 0000000000000000000000000000000000000000..116cf0506f919a94e783c1eda4cc59f510666a95 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Ol_Onal.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1E5FF); +set.addRange(0x1E5D0, 0x1E5FA); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Hungarian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Hungarian.js new file mode 100644 index 0000000000000000000000000000000000000000..4f09cd61da990b52d2e31d4a3bf5678c2d35263b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Hungarian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10CFA, 0x10CFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Italic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Italic.js new file mode 100644 index 0000000000000000000000000000000000000000..41a375afbf7adedebe1442de1f3eb9553b22bc6c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Italic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10300, 0x10323).addRange(0x1032D, 0x1032F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_North_Arabian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_North_Arabian.js new file mode 100644 index 0000000000000000000000000000000000000000..d7c513e113c0460b6fcf0b5fb6922c06d51f9123 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_North_Arabian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10A80, 0x10A9F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Permic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Permic.js new file mode 100644 index 0000000000000000000000000000000000000000..fba61785d88ac6b103de6c1267997a695f129315 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Permic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10350, 0x1037A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Persian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Persian.js new file mode 100644 index 0000000000000000000000000000000000000000..93cdf7b4b16016b1e2ce14e60a7c074c0a978899 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Persian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103D5); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Sogdian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Sogdian.js new file mode 100644 index 0000000000000000000000000000000000000000..40587873083dc9ab4dac4a2c84f5269c397a2ee4 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Sogdian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10F00, 0x10F27); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_South_Arabian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_South_Arabian.js new file mode 100644 index 0000000000000000000000000000000000000000..0d1a33f380957ba87d41269b312579b433e3e4a0 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_South_Arabian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10A60, 0x10A7F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Turkic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Turkic.js new file mode 100644 index 0000000000000000000000000000000000000000..eef025feccbdd3ac846de31eb650949b23021414 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Turkic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10C00, 0x10C48); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Uyghur.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Uyghur.js new file mode 100644 index 0000000000000000000000000000000000000000..cba35799367bc61bb1a980b1e195081de8060abb --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Old_Uyghur.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10F70, 0x10F89); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Oriya.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Oriya.js new file mode 100644 index 0000000000000000000000000000000000000000..00649ecfd882659d0eb08062438c87c5b7d24a1b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Oriya.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xB01, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB3C, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4D).addRange(0xB55, 0xB57).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB63).addRange(0xB66, 0xB77); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Osage.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Osage.js new file mode 100644 index 0000000000000000000000000000000000000000..4bf94a08dfcf5b3ed9c70303dcb8d70144986838 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Osage.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Osmanya.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Osmanya.js new file mode 100644 index 0000000000000000000000000000000000000000..bb6ec9a73bd6b2954896cdff1063a6d9953bb819 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Osmanya.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10480, 0x1049D).addRange(0x104A0, 0x104A9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Pahawh_Hmong.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Pahawh_Hmong.js new file mode 100644 index 0000000000000000000000000000000000000000..b68ce3b294b854e054fe2c3461ed7bb69511a533 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Pahawh_Hmong.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16B00, 0x16B45).addRange(0x16B50, 0x16B59).addRange(0x16B5B, 0x16B61).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Palmyrene.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Palmyrene.js new file mode 100644 index 0000000000000000000000000000000000000000..6a4dde98bc217be4ed0d5794448bd7fa11a2e0ea --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Palmyrene.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10860, 0x1087F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Pau_Cin_Hau.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Pau_Cin_Hau.js new file mode 100644 index 0000000000000000000000000000000000000000..0cba5d2b3e827c9dd82f4351990ce86080afdb85 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Pau_Cin_Hau.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11AC0, 0x11AF8); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Phags_Pa.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Phags_Pa.js new file mode 100644 index 0000000000000000000000000000000000000000..04e6f648093b095bcad42a78abf866050c6ffa63 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Phags_Pa.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA840, 0xA877); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Phoenician.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Phoenician.js new file mode 100644 index 0000000000000000000000000000000000000000..9a518b9a830d9ab0802f815fa02b1fd0326846f3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Phoenician.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1091F); +set.addRange(0x10900, 0x1091B); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Psalter_Pahlavi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Psalter_Pahlavi.js new file mode 100644 index 0000000000000000000000000000000000000000..2c384c6d3ba1d6a5ffdb8e390acc16a77976a88a --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Psalter_Pahlavi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10B80, 0x10B91).addRange(0x10B99, 0x10B9C).addRange(0x10BA9, 0x10BAF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Rejang.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Rejang.js new file mode 100644 index 0000000000000000000000000000000000000000..cd06ee4b481db260759ca79e50fa45581cd9b37b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Rejang.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xA95F); +set.addRange(0xA930, 0xA953); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Runic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Runic.js new file mode 100644 index 0000000000000000000000000000000000000000..997a8966c5742680414811a69b6df5b70d386091 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Runic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16A0, 0x16EA).addRange(0x16EE, 0x16F8); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Samaritan.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Samaritan.js new file mode 100644 index 0000000000000000000000000000000000000000..22d5094aabf3b579874baf102d4694e193827e69 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Samaritan.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x800, 0x82D).addRange(0x830, 0x83E); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Saurashtra.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Saurashtra.js new file mode 100644 index 0000000000000000000000000000000000000000..4b196b6475bf07c74ec78b6fb08b8749c41be850 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Saurashtra.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA880, 0xA8C5).addRange(0xA8CE, 0xA8D9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Sharada.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sharada.js new file mode 100644 index 0000000000000000000000000000000000000000..6632b06ad8b5cc62419173015410c1387e1d1b3e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sharada.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11180, 0x111DF).addRange(0x11B60, 0x11B67); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Shavian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Shavian.js new file mode 100644 index 0000000000000000000000000000000000000000..fdf77b73181f9c929733f467046eb84fd221134e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Shavian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10450, 0x1047F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Siddham.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Siddham.js new file mode 100644 index 0000000000000000000000000000000000000000..ae71aa7d557edd4ffd31853eab168dc4499065a8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Siddham.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11580, 0x115B5).addRange(0x115B8, 0x115DD); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Sidetic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sidetic.js new file mode 100644 index 0000000000000000000000000000000000000000..9ae69e8b199d1745dcaacc75c5e2fdf584bdb5f9 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sidetic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10940, 0x10959); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/SignWriting.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/SignWriting.js new file mode 100644 index 0000000000000000000000000000000000000000..0a20f3822af406222ccb393793fcb4e25d4951e9 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/SignWriting.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1D800, 0x1DA8B).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Sinhala.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sinhala.js new file mode 100644 index 0000000000000000000000000000000000000000..b31f6a840a47f2dc2a766787e15d490cc1afe944 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sinhala.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xDBD, 0xDCA, 0xDD6); +set.addRange(0xD81, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDE6, 0xDEF).addRange(0xDF2, 0xDF4).addRange(0x111E1, 0x111F4); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Sogdian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sogdian.js new file mode 100644 index 0000000000000000000000000000000000000000..e1e22aaf454a95bfd0114d701bc149991d93c924 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sogdian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10F30, 0x10F59); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Sora_Sompeng.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sora_Sompeng.js new file mode 100644 index 0000000000000000000000000000000000000000..4bd1e2123fcf3b722f546fb57103fa463df1b54c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sora_Sompeng.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x110D0, 0x110E8).addRange(0x110F0, 0x110F9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Soyombo.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Soyombo.js new file mode 100644 index 0000000000000000000000000000000000000000..d7bb08b175412d8baed4b1f3e3f7af5af1f19c3d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Soyombo.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11A50, 0x11AA2); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Sundanese.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sundanese.js new file mode 100644 index 0000000000000000000000000000000000000000..2834227ce39d8aabc7d3e7e25c26b9b4eec25bbe --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sundanese.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1B80, 0x1BBF).addRange(0x1CC0, 0x1CC7); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Sunuwar.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sunuwar.js new file mode 100644 index 0000000000000000000000000000000000000000..be63e1f6224e3bacb067eabc04fda65a8f4e918c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Sunuwar.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11BC0, 0x11BE1).addRange(0x11BF0, 0x11BF9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Syloti_Nagri.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Syloti_Nagri.js new file mode 100644 index 0000000000000000000000000000000000000000..fcd725ee7fbe66215594fd7e0471021f9e151178 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Syloti_Nagri.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA800, 0xA82C); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Syriac.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Syriac.js new file mode 100644 index 0000000000000000000000000000000000000000..29c76d8b16cf8daccf1c130e93e107be4b484c99 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Syriac.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x700, 0x70D).addRange(0x70F, 0x74A).addRange(0x74D, 0x74F).addRange(0x860, 0x86A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tagalog.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tagalog.js new file mode 100644 index 0000000000000000000000000000000000000000..28a2d7574f2020e13da28dbaa4dd84b288c704b7 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tagalog.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x171F); +set.addRange(0x1700, 0x1715); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tagbanwa.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tagbanwa.js new file mode 100644 index 0000000000000000000000000000000000000000..1439193e109df746ba61a1fb17bfc9b5231ea7be --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tagbanwa.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1772, 0x1773); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tai_Le.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tai_Le.js new file mode 100644 index 0000000000000000000000000000000000000000..cf231955d955fdbd2e9a165a8fa1055b3d1cb8ad --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tai_Le.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1950, 0x196D).addRange(0x1970, 0x1974); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tai_Tham.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tai_Tham.js new file mode 100644 index 0000000000000000000000000000000000000000..985b631899ed98433f4d7591f01cb4235e608911 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tai_Tham.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1A20, 0x1A5E).addRange(0x1A60, 0x1A7C).addRange(0x1A7F, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1AA0, 0x1AAD); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tai_Viet.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tai_Viet.js new file mode 100644 index 0000000000000000000000000000000000000000..78bf73897bfbd1f1e701299283163020b3f62190 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tai_Viet.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xAA80, 0xAAC2).addRange(0xAADB, 0xAADF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tai_Yo.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tai_Yo.js new file mode 100644 index 0000000000000000000000000000000000000000..f113c0bc8b8026eddc3062f4f9d47dad6b7b2fcd --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tai_Yo.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1E6C0, 0x1E6DE).addRange(0x1E6E0, 0x1E6F5).addRange(0x1E6FE, 0x1E6FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Takri.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Takri.js new file mode 100644 index 0000000000000000000000000000000000000000..94432f3bbee020a123d4f670b0dec3661a7820ed --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Takri.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11680, 0x116B9).addRange(0x116C0, 0x116C9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tamil.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tamil.js new file mode 100644 index 0000000000000000000000000000000000000000..2b11f0acb2a4c55610e028b5e72d8faaa8f2c2c2 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tamil.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB9C, 0xBD0, 0xBD7, 0x11FFF); +set.addRange(0xB82, 0xB83).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCD).addRange(0xBE6, 0xBFA).addRange(0x11FC0, 0x11FF1); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tangsa.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tangsa.js new file mode 100644 index 0000000000000000000000000000000000000000..423e125591a52cfccfe89f95e4ee976d4aa034f7 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tangsa.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16A70, 0x16ABE).addRange(0x16AC0, 0x16AC9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tangut.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tangut.js new file mode 100644 index 0000000000000000000000000000000000000000..ff3dfe0a4fe82e3471ec5dd20b9565cf2d00ab71 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tangut.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x16FE0); +set.addRange(0x17000, 0x18AFF).addRange(0x18D00, 0x18D1E).addRange(0x18D80, 0x18DF2); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Telugu.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Telugu.js new file mode 100644 index 0000000000000000000000000000000000000000..13662c8972ba61b26ff264e07b3d95aa02d35cf2 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Telugu.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xC00, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC3C, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC58, 0xC5A).addRange(0xC5C, 0xC5D).addRange(0xC60, 0xC63).addRange(0xC66, 0xC6F).addRange(0xC77, 0xC7F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Thaana.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Thaana.js new file mode 100644 index 0000000000000000000000000000000000000000..1eac134dd3e006129d5e0b524777d9a135d9547a --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Thaana.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x780, 0x7B1); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Thai.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Thai.js new file mode 100644 index 0000000000000000000000000000000000000000..58b4fba75336e933f6d439e5dee137f00e51b827 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Thai.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xE01, 0xE3A).addRange(0xE40, 0xE5B); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tibetan.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tibetan.js new file mode 100644 index 0000000000000000000000000000000000000000..cc3bbfb87a205739b8a410bd9071167e156ea75c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tibetan.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xF00, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF71, 0xF97).addRange(0xF99, 0xFBC).addRange(0xFBE, 0xFCC).addRange(0xFCE, 0xFD4).addRange(0xFD9, 0xFDA); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tifinagh.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tifinagh.js new file mode 100644 index 0000000000000000000000000000000000000000..4dd6b67ebe99f57cce4adbe231660aa810abf27b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tifinagh.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2D7F); +set.addRange(0x2D30, 0x2D67).addRange(0x2D6F, 0x2D70); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tirhuta.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tirhuta.js new file mode 100644 index 0000000000000000000000000000000000000000..ab8a4b6fdea974265150ae89a69bf7daceddfa58 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tirhuta.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11480, 0x114C7).addRange(0x114D0, 0x114D9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Todhri.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Todhri.js new file mode 100644 index 0000000000000000000000000000000000000000..a5c562a26ff778ff9a8c15766e74f273549e56de --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Todhri.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x105C0, 0x105F3); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tolong_Siki.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tolong_Siki.js new file mode 100644 index 0000000000000000000000000000000000000000..a0bd3cee699c2f037a0e7f20015ef75d5da787e6 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tolong_Siki.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11DB0, 0x11DDB).addRange(0x11DE0, 0x11DE9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Toto.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Toto.js new file mode 100644 index 0000000000000000000000000000000000000000..b3eaebea5bc3220b333dd67253292ba42548e5d7 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Toto.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1E290, 0x1E2AE); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Tulu_Tigalari.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tulu_Tigalari.js new file mode 100644 index 0000000000000000000000000000000000000000..f3fd1579ceea52f8325b341fe6bd4f69eba7114e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Tulu_Tigalari.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1138B, 0x1138E, 0x113C2, 0x113C5); +set.addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x113B7, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113D5).addRange(0x113D7, 0x113D8).addRange(0x113E1, 0x113E2); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Ugaritic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Ugaritic.js new file mode 100644 index 0000000000000000000000000000000000000000..dd9160bee68d90edfe181ee530c9a26360a5db12 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Ugaritic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1039F); +set.addRange(0x10380, 0x1039D); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Unknown.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Unknown.js new file mode 100644 index 0000000000000000000000000000000000000000..53a35fff971af875a93fa0e65faaf7e4b80307ae --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Unknown.js @@ -0,0 +1,12 @@ +const set = require('regenerate')(0x38B, 0x38D, 0x3A2, 0x530, 0x590, 0x70E, 0x83F, 0x85F, 0x984, 0x9A9, 0x9B1, 0x9DE, 0xA04, 0xA29, 0xA31, 0xA34, 0xA37, 0xA3D, 0xA5D, 0xA84, 0xA8E, 0xA92, 0xAA9, 0xAB1, 0xAB4, 0xAC6, 0xACA, 0xB00, 0xB04, 0xB29, 0xB31, 0xB34, 0xB5E, 0xB84, 0xB91, 0xB9B, 0xB9D, 0xBC9, 0xC0D, 0xC11, 0xC29, 0xC45, 0xC49, 0xC57, 0xC5B, 0xC8D, 0xC91, 0xCA9, 0xCB4, 0xCC5, 0xCC9, 0xCDF, 0xCF0, 0xD0D, 0xD11, 0xD45, 0xD49, 0xD80, 0xD84, 0xDB2, 0xDBC, 0xDD5, 0xDD7, 0xE83, 0xE85, 0xE8B, 0xEA4, 0xEA6, 0xEC5, 0xEC7, 0xECF, 0xF48, 0xF98, 0xFBD, 0xFCD, 0x10C6, 0x1249, 0x1257, 0x1259, 0x1289, 0x12B1, 0x12BF, 0x12C1, 0x12D7, 0x1311, 0x176D, 0x1771, 0x191F, 0x1A5F, 0x1B4D, 0x1F58, 0x1F5A, 0x1F5C, 0x1F5E, 0x1FB5, 0x1FC5, 0x1FDC, 0x1FF5, 0x1FFF, 0x2065, 0x208F, 0x2D26, 0x2DA7, 0x2DAF, 0x2DB7, 0x2DBF, 0x2DC7, 0x2DCF, 0x2DD7, 0x2DDF, 0x2E9A, 0x3040, 0x3130, 0x318F, 0x321F, 0xA9CE, 0xA9FF, 0xAB27, 0xAB2F, 0xFB37, 0xFB3D, 0xFB3F, 0xFB42, 0xFB45, 0xFE53, 0xFE67, 0xFE75, 0xFF00, 0xFFE7, 0x1000C, 0x10027, 0x1003B, 0x1003E, 0x1018F, 0x1039E, 0x1057B, 0x1058B, 0x10593, 0x10596, 0x105A2, 0x105B2, 0x105BA, 0x10786, 0x107B1, 0x10809, 0x10836, 0x10856, 0x108F3, 0x10A04, 0x10A14, 0x10A18, 0x10E7F, 0x10EAA, 0x11135, 0x111E0, 0x11212, 0x11287, 0x11289, 0x1128E, 0x1129E, 0x11304, 0x11329, 0x11331, 0x11334, 0x1133A, 0x1138A, 0x1138F, 0x113B6, 0x113C1, 0x113C6, 0x113CB, 0x113D6, 0x1145C, 0x11914, 0x11917, 0x11936, 0x11C09, 0x11C37, 0x11CA8, 0x11D07, 0x11D0A, 0x11D3B, 0x11D3E, 0x11D66, 0x11D69, 0x11D8F, 0x11D92, 0x11F11, 0x1246F, 0x16A5F, 0x16ABF, 0x16B5A, 0x16B62, 0x1AFF4, 0x1AFFC, 0x1AFFF, 0x1D455, 0x1D49D, 0x1D4AD, 0x1D4BA, 0x1D4BC, 0x1D4C4, 0x1D506, 0x1D515, 0x1D51D, 0x1D53A, 0x1D53F, 0x1D545, 0x1D551, 0x1DAA0, 0x1E007, 0x1E022, 0x1E025, 0x1E6DF, 0x1E7E7, 0x1E7EC, 0x1E7EF, 0x1E7FF, 0x1EE04, 0x1EE20, 0x1EE23, 0x1EE28, 0x1EE33, 0x1EE38, 0x1EE3A, 0x1EE48, 0x1EE4A, 0x1EE4C, 0x1EE50, 0x1EE53, 0x1EE58, 0x1EE5A, 0x1EE5C, 0x1EE5E, 0x1EE60, 0x1EE63, 0x1EE6B, 0x1EE73, 0x1EE78, 0x1EE7D, 0x1EE7F, 0x1EE8A, 0x1EEA4, 0x1EEAA, 0x1F0C0, 0x1F0D0, 0x1FAC7, 0x1FB93); +set.addRange(0x378, 0x379).addRange(0x380, 0x383).addRange(0x557, 0x558).addRange(0x58B, 0x58C).addRange(0x5C8, 0x5CF).addRange(0x5EB, 0x5EE).addRange(0x5F5, 0x5FF).addRange(0x74B, 0x74C).addRange(0x7B2, 0x7BF).addRange(0x7FB, 0x7FC).addRange(0x82E, 0x82F).addRange(0x85C, 0x85D).addRange(0x86B, 0x86F).addRange(0x892, 0x896).addRange(0x98D, 0x98E).addRange(0x991, 0x992).addRange(0x9B3, 0x9B5).addRange(0x9BA, 0x9BB).addRange(0x9C5, 0x9C6).addRange(0x9C9, 0x9CA).addRange(0x9CF, 0x9D6).addRange(0x9D8, 0x9DB).addRange(0x9E4, 0x9E5).addRange(0x9FF, 0xA00).addRange(0xA0B, 0xA0E).addRange(0xA11, 0xA12).addRange(0xA3A, 0xA3B).addRange(0xA43, 0xA46).addRange(0xA49, 0xA4A).addRange(0xA4E, 0xA50).addRange(0xA52, 0xA58).addRange(0xA5F, 0xA65).addRange(0xA77, 0xA80).addRange(0xABA, 0xABB).addRange(0xACE, 0xACF).addRange(0xAD1, 0xADF).addRange(0xAE4, 0xAE5).addRange(0xAF2, 0xAF8).addRange(0xB0D, 0xB0E).addRange(0xB11, 0xB12).addRange(0xB3A, 0xB3B).addRange(0xB45, 0xB46).addRange(0xB49, 0xB4A).addRange(0xB4E, 0xB54).addRange(0xB58, 0xB5B).addRange(0xB64, 0xB65).addRange(0xB78, 0xB81).addRange(0xB8B, 0xB8D).addRange(0xB96, 0xB98).addRange(0xBA0, 0xBA2).addRange(0xBA5, 0xBA7); +set.addRange(0xBAB, 0xBAD).addRange(0xBBA, 0xBBD).addRange(0xBC3, 0xBC5).addRange(0xBCE, 0xBCF).addRange(0xBD1, 0xBD6).addRange(0xBD8, 0xBE5).addRange(0xBFB, 0xBFF).addRange(0xC3A, 0xC3B).addRange(0xC4E, 0xC54).addRange(0xC5E, 0xC5F).addRange(0xC64, 0xC65).addRange(0xC70, 0xC76).addRange(0xCBA, 0xCBB).addRange(0xCCE, 0xCD4).addRange(0xCD7, 0xCDB).addRange(0xCE4, 0xCE5).addRange(0xCF4, 0xCFF).addRange(0xD50, 0xD53).addRange(0xD64, 0xD65).addRange(0xD97, 0xD99).addRange(0xDBE, 0xDBF).addRange(0xDC7, 0xDC9).addRange(0xDCB, 0xDCE).addRange(0xDE0, 0xDE5).addRange(0xDF0, 0xDF1).addRange(0xDF5, 0xE00).addRange(0xE3B, 0xE3E).addRange(0xE5C, 0xE80).addRange(0xEBE, 0xEBF).addRange(0xEDA, 0xEDB).addRange(0xEE0, 0xEFF).addRange(0xF6D, 0xF70).addRange(0xFDB, 0xFFF).addRange(0x10C8, 0x10CC).addRange(0x10CE, 0x10CF).addRange(0x124E, 0x124F).addRange(0x125E, 0x125F).addRange(0x128E, 0x128F).addRange(0x12B6, 0x12B7).addRange(0x12C6, 0x12C7).addRange(0x1316, 0x1317).addRange(0x135B, 0x135C).addRange(0x137D, 0x137F).addRange(0x139A, 0x139F).addRange(0x13F6, 0x13F7).addRange(0x13FE, 0x13FF).addRange(0x169D, 0x169F).addRange(0x16F9, 0x16FF).addRange(0x1716, 0x171E).addRange(0x1737, 0x173F).addRange(0x1754, 0x175F); +set.addRange(0x1774, 0x177F).addRange(0x17DE, 0x17DF).addRange(0x17EA, 0x17EF).addRange(0x17FA, 0x17FF).addRange(0x181A, 0x181F).addRange(0x1879, 0x187F).addRange(0x18AB, 0x18AF).addRange(0x18F6, 0x18FF).addRange(0x192C, 0x192F).addRange(0x193C, 0x193F).addRange(0x1941, 0x1943).addRange(0x196E, 0x196F).addRange(0x1975, 0x197F).addRange(0x19AC, 0x19AF).addRange(0x19CA, 0x19CF).addRange(0x19DB, 0x19DD).addRange(0x1A1C, 0x1A1D).addRange(0x1A7D, 0x1A7E).addRange(0x1A8A, 0x1A8F).addRange(0x1A9A, 0x1A9F).addRange(0x1AAE, 0x1AAF).addRange(0x1ADE, 0x1ADF).addRange(0x1AEC, 0x1AFF).addRange(0x1BF4, 0x1BFB).addRange(0x1C38, 0x1C3A).addRange(0x1C4A, 0x1C4C).addRange(0x1C8B, 0x1C8F).addRange(0x1CBB, 0x1CBC).addRange(0x1CC8, 0x1CCF).addRange(0x1CFB, 0x1CFF).addRange(0x1F16, 0x1F17).addRange(0x1F1E, 0x1F1F).addRange(0x1F46, 0x1F47).addRange(0x1F4E, 0x1F4F).addRange(0x1F7E, 0x1F7F).addRange(0x1FD4, 0x1FD5).addRange(0x1FF0, 0x1FF1).addRange(0x2072, 0x2073).addRange(0x209D, 0x209F).addRange(0x20C2, 0x20CF).addRange(0x20F1, 0x20FF).addRange(0x218C, 0x218F).addRange(0x242A, 0x243F).addRange(0x244B, 0x245F).addRange(0x2B74, 0x2B75).addRange(0x2CF4, 0x2CF8).addRange(0x2D28, 0x2D2C).addRange(0x2D2E, 0x2D2F).addRange(0x2D68, 0x2D6E).addRange(0x2D71, 0x2D7E).addRange(0x2D97, 0x2D9F); +set.addRange(0x2E5E, 0x2E7F).addRange(0x2EF4, 0x2EFF).addRange(0x2FD6, 0x2FEF).addRange(0x3097, 0x3098).addRange(0x3100, 0x3104).addRange(0x31E6, 0x31EE).addRange(0xA48D, 0xA48F).addRange(0xA4C7, 0xA4CF).addRange(0xA62C, 0xA63F).addRange(0xA6F8, 0xA6FF).addRange(0xA7DD, 0xA7F0).addRange(0xA82D, 0xA82F).addRange(0xA83A, 0xA83F).addRange(0xA878, 0xA87F).addRange(0xA8C6, 0xA8CD).addRange(0xA8DA, 0xA8DF).addRange(0xA954, 0xA95E).addRange(0xA97D, 0xA97F).addRange(0xA9DA, 0xA9DD).addRange(0xAA37, 0xAA3F).addRange(0xAA4E, 0xAA4F).addRange(0xAA5A, 0xAA5B).addRange(0xAAC3, 0xAADA).addRange(0xAAF7, 0xAB00).addRange(0xAB07, 0xAB08).addRange(0xAB0F, 0xAB10).addRange(0xAB17, 0xAB1F).addRange(0xAB6C, 0xAB6F).addRange(0xABEE, 0xABEF).addRange(0xABFA, 0xABFF).addRange(0xD7A4, 0xD7AF).addRange(0xD7C7, 0xD7CA).addRange(0xD7FC, 0xF8FF).addRange(0xFA6E, 0xFA6F).addRange(0xFADA, 0xFAFF).addRange(0xFB07, 0xFB12).addRange(0xFB18, 0xFB1C).addRange(0xFDD0, 0xFDEF).addRange(0xFE1A, 0xFE1F).addRange(0xFE6C, 0xFE6F).addRange(0xFEFD, 0xFEFE).addRange(0xFFBF, 0xFFC1).addRange(0xFFC8, 0xFFC9).addRange(0xFFD0, 0xFFD1).addRange(0xFFD8, 0xFFD9).addRange(0xFFDD, 0xFFDF).addRange(0xFFEF, 0xFFF8).addRange(0xFFFE, 0xFFFF).addRange(0x1004E, 0x1004F).addRange(0x1005E, 0x1007F).addRange(0x100FB, 0x100FF); +set.addRange(0x10103, 0x10106).addRange(0x10134, 0x10136).addRange(0x1019D, 0x1019F).addRange(0x101A1, 0x101CF).addRange(0x101FE, 0x1027F).addRange(0x1029D, 0x1029F).addRange(0x102D1, 0x102DF).addRange(0x102FC, 0x102FF).addRange(0x10324, 0x1032C).addRange(0x1034B, 0x1034F).addRange(0x1037B, 0x1037F).addRange(0x103C4, 0x103C7).addRange(0x103D6, 0x103FF).addRange(0x1049E, 0x1049F).addRange(0x104AA, 0x104AF).addRange(0x104D4, 0x104D7).addRange(0x104FC, 0x104FF).addRange(0x10528, 0x1052F).addRange(0x10564, 0x1056E).addRange(0x105BD, 0x105BF).addRange(0x105F4, 0x105FF).addRange(0x10737, 0x1073F).addRange(0x10756, 0x1075F).addRange(0x10768, 0x1077F).addRange(0x107BB, 0x107FF).addRange(0x10806, 0x10807).addRange(0x10839, 0x1083B).addRange(0x1083D, 0x1083E).addRange(0x1089F, 0x108A6).addRange(0x108B0, 0x108DF).addRange(0x108F6, 0x108FA).addRange(0x1091C, 0x1091E).addRange(0x1093A, 0x1093E).addRange(0x1095A, 0x1097F).addRange(0x109B8, 0x109BB).addRange(0x109D0, 0x109D1).addRange(0x10A07, 0x10A0B).addRange(0x10A36, 0x10A37).addRange(0x10A3B, 0x10A3E).addRange(0x10A49, 0x10A4F).addRange(0x10A59, 0x10A5F).addRange(0x10AA0, 0x10ABF).addRange(0x10AE7, 0x10AEA).addRange(0x10AF7, 0x10AFF).addRange(0x10B36, 0x10B38).addRange(0x10B56, 0x10B57).addRange(0x10B73, 0x10B77).addRange(0x10B92, 0x10B98).addRange(0x10B9D, 0x10BA8).addRange(0x10BB0, 0x10BFF).addRange(0x10C49, 0x10C7F); +set.addRange(0x10CB3, 0x10CBF).addRange(0x10CF3, 0x10CF9).addRange(0x10D28, 0x10D2F).addRange(0x10D3A, 0x10D3F).addRange(0x10D66, 0x10D68).addRange(0x10D86, 0x10D8D).addRange(0x10D90, 0x10E5F).addRange(0x10EAE, 0x10EAF).addRange(0x10EB2, 0x10EC1).addRange(0x10EC8, 0x10ECF).addRange(0x10ED9, 0x10EF9).addRange(0x10F28, 0x10F2F).addRange(0x10F5A, 0x10F6F).addRange(0x10F8A, 0x10FAF).addRange(0x10FCC, 0x10FDF).addRange(0x10FF7, 0x10FFF).addRange(0x1104E, 0x11051).addRange(0x11076, 0x1107E).addRange(0x110C3, 0x110CC).addRange(0x110CE, 0x110CF).addRange(0x110E9, 0x110EF).addRange(0x110FA, 0x110FF).addRange(0x11148, 0x1114F).addRange(0x11177, 0x1117F).addRange(0x111F5, 0x111FF).addRange(0x11242, 0x1127F).addRange(0x112AA, 0x112AF).addRange(0x112EB, 0x112EF).addRange(0x112FA, 0x112FF).addRange(0x1130D, 0x1130E).addRange(0x11311, 0x11312).addRange(0x11345, 0x11346).addRange(0x11349, 0x1134A).addRange(0x1134E, 0x1134F).addRange(0x11351, 0x11356).addRange(0x11358, 0x1135C).addRange(0x11364, 0x11365).addRange(0x1136D, 0x1136F).addRange(0x11375, 0x1137F).addRange(0x1138C, 0x1138D).addRange(0x113C3, 0x113C4).addRange(0x113D9, 0x113E0).addRange(0x113E3, 0x113FF).addRange(0x11462, 0x1147F).addRange(0x114C8, 0x114CF).addRange(0x114DA, 0x1157F).addRange(0x115B6, 0x115B7).addRange(0x115DE, 0x115FF).addRange(0x11645, 0x1164F).addRange(0x1165A, 0x1165F).addRange(0x1166D, 0x1167F); +set.addRange(0x116BA, 0x116BF).addRange(0x116CA, 0x116CF).addRange(0x116E4, 0x116FF).addRange(0x1171B, 0x1171C).addRange(0x1172C, 0x1172F).addRange(0x11747, 0x117FF).addRange(0x1183C, 0x1189F).addRange(0x118F3, 0x118FE).addRange(0x11907, 0x11908).addRange(0x1190A, 0x1190B).addRange(0x11939, 0x1193A).addRange(0x11947, 0x1194F).addRange(0x1195A, 0x1199F).addRange(0x119A8, 0x119A9).addRange(0x119D8, 0x119D9).addRange(0x119E5, 0x119FF).addRange(0x11A48, 0x11A4F).addRange(0x11AA3, 0x11AAF).addRange(0x11AF9, 0x11AFF).addRange(0x11B0A, 0x11B5F).addRange(0x11B68, 0x11BBF).addRange(0x11BE2, 0x11BEF).addRange(0x11BFA, 0x11BFF).addRange(0x11C46, 0x11C4F).addRange(0x11C6D, 0x11C6F).addRange(0x11C90, 0x11C91).addRange(0x11CB7, 0x11CFF).addRange(0x11D37, 0x11D39).addRange(0x11D48, 0x11D4F).addRange(0x11D5A, 0x11D5F).addRange(0x11D99, 0x11D9F).addRange(0x11DAA, 0x11DAF).addRange(0x11DDC, 0x11DDF).addRange(0x11DEA, 0x11EDF).addRange(0x11EF9, 0x11EFF).addRange(0x11F3B, 0x11F3D).addRange(0x11F5B, 0x11FAF).addRange(0x11FB1, 0x11FBF).addRange(0x11FF2, 0x11FFE).addRange(0x1239A, 0x123FF).addRange(0x12475, 0x1247F).addRange(0x12544, 0x12F8F).addRange(0x12FF3, 0x12FFF).addRange(0x13456, 0x1345F).addRange(0x143FB, 0x143FF).addRange(0x14647, 0x160FF).addRange(0x1613A, 0x167FF).addRange(0x16A39, 0x16A3F).addRange(0x16A6A, 0x16A6D).addRange(0x16ACA, 0x16ACF).addRange(0x16AEE, 0x16AEF); +set.addRange(0x16AF6, 0x16AFF).addRange(0x16B46, 0x16B4F).addRange(0x16B78, 0x16B7C).addRange(0x16B90, 0x16D3F).addRange(0x16D7A, 0x16E3F).addRange(0x16E9B, 0x16E9F).addRange(0x16EB9, 0x16EBA).addRange(0x16ED4, 0x16EFF).addRange(0x16F4B, 0x16F4E).addRange(0x16F88, 0x16F8E).addRange(0x16FA0, 0x16FDF).addRange(0x16FE5, 0x16FEF).addRange(0x16FF7, 0x16FFF).addRange(0x18CD6, 0x18CFE).addRange(0x18D1F, 0x18D7F).addRange(0x18DF3, 0x1AFEF).addRange(0x1B123, 0x1B131).addRange(0x1B133, 0x1B14F).addRange(0x1B153, 0x1B154).addRange(0x1B156, 0x1B163).addRange(0x1B168, 0x1B16F).addRange(0x1B2FC, 0x1BBFF).addRange(0x1BC6B, 0x1BC6F).addRange(0x1BC7D, 0x1BC7F).addRange(0x1BC89, 0x1BC8F).addRange(0x1BC9A, 0x1BC9B).addRange(0x1BCA4, 0x1CBFF).addRange(0x1CCFD, 0x1CCFF).addRange(0x1CEB4, 0x1CEB9).addRange(0x1CED1, 0x1CEDF).addRange(0x1CEF1, 0x1CEFF).addRange(0x1CF2E, 0x1CF2F).addRange(0x1CF47, 0x1CF4F).addRange(0x1CFC4, 0x1CFFF).addRange(0x1D0F6, 0x1D0FF).addRange(0x1D127, 0x1D128).addRange(0x1D1EB, 0x1D1FF).addRange(0x1D246, 0x1D2BF).addRange(0x1D2D4, 0x1D2DF).addRange(0x1D2F4, 0x1D2FF).addRange(0x1D357, 0x1D35F).addRange(0x1D379, 0x1D3FF).addRange(0x1D4A0, 0x1D4A1).addRange(0x1D4A3, 0x1D4A4).addRange(0x1D4A7, 0x1D4A8).addRange(0x1D50B, 0x1D50C).addRange(0x1D547, 0x1D549).addRange(0x1D6A6, 0x1D6A7).addRange(0x1D7CC, 0x1D7CD).addRange(0x1DA8C, 0x1DA9A).addRange(0x1DAB0, 0x1DEFF); +set.addRange(0x1DF1F, 0x1DF24).addRange(0x1DF2B, 0x1DFFF).addRange(0x1E019, 0x1E01A).addRange(0x1E02B, 0x1E02F).addRange(0x1E06E, 0x1E08E).addRange(0x1E090, 0x1E0FF).addRange(0x1E12D, 0x1E12F).addRange(0x1E13E, 0x1E13F).addRange(0x1E14A, 0x1E14D).addRange(0x1E150, 0x1E28F).addRange(0x1E2AF, 0x1E2BF).addRange(0x1E2FA, 0x1E2FE).addRange(0x1E300, 0x1E4CF).addRange(0x1E4FA, 0x1E5CF).addRange(0x1E5FB, 0x1E5FE).addRange(0x1E600, 0x1E6BF).addRange(0x1E6F6, 0x1E6FD).addRange(0x1E700, 0x1E7DF).addRange(0x1E8C5, 0x1E8C6).addRange(0x1E8D7, 0x1E8FF).addRange(0x1E94C, 0x1E94F).addRange(0x1E95A, 0x1E95D).addRange(0x1E960, 0x1EC70).addRange(0x1ECB5, 0x1ED00).addRange(0x1ED3E, 0x1EDFF).addRange(0x1EE25, 0x1EE26).addRange(0x1EE3C, 0x1EE41).addRange(0x1EE43, 0x1EE46).addRange(0x1EE55, 0x1EE56).addRange(0x1EE65, 0x1EE66).addRange(0x1EE9C, 0x1EEA0).addRange(0x1EEBC, 0x1EEEF).addRange(0x1EEF2, 0x1EFFF).addRange(0x1F02C, 0x1F02F).addRange(0x1F094, 0x1F09F).addRange(0x1F0AF, 0x1F0B0).addRange(0x1F0F6, 0x1F0FF).addRange(0x1F1AE, 0x1F1E5).addRange(0x1F203, 0x1F20F).addRange(0x1F23C, 0x1F23F).addRange(0x1F249, 0x1F24F).addRange(0x1F252, 0x1F25F).addRange(0x1F266, 0x1F2FF).addRange(0x1F6D9, 0x1F6DB).addRange(0x1F6ED, 0x1F6EF).addRange(0x1F6FD, 0x1F6FF).addRange(0x1F7DA, 0x1F7DF).addRange(0x1F7EC, 0x1F7EF).addRange(0x1F7F1, 0x1F7FF).addRange(0x1F80C, 0x1F80F).addRange(0x1F848, 0x1F84F); +set.addRange(0x1F85A, 0x1F85F).addRange(0x1F888, 0x1F88F).addRange(0x1F8AE, 0x1F8AF).addRange(0x1F8BC, 0x1F8BF).addRange(0x1F8C2, 0x1F8CF).addRange(0x1F8D9, 0x1F8FF).addRange(0x1FA58, 0x1FA5F).addRange(0x1FA6E, 0x1FA6F).addRange(0x1FA7D, 0x1FA7F).addRange(0x1FA8B, 0x1FA8D).addRange(0x1FAC9, 0x1FACC).addRange(0x1FADD, 0x1FADE).addRange(0x1FAEB, 0x1FAEE).addRange(0x1FAF9, 0x1FAFF).addRange(0x1FBFB, 0x1FFFF).addRange(0x2A6E0, 0x2A6FF).addRange(0x2B81E, 0x2B81F).addRange(0x2CEAE, 0x2CEAF).addRange(0x2EBE1, 0x2EBEF).addRange(0x2EE5E, 0x2F7FF).addRange(0x2FA1E, 0x2FFFF).addRange(0x3134B, 0x3134F).addRange(0x3347A, 0xE0000).addRange(0xE0002, 0xE001F).addRange(0xE0080, 0xE00FF).addRange(0xE01F0, 0x10FFFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Vai.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Vai.js new file mode 100644 index 0000000000000000000000000000000000000000..e06faa6a4964df65869718f18f2df0406d1d6790 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Vai.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA500, 0xA62B); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Vithkuqi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Vithkuqi.js new file mode 100644 index 0000000000000000000000000000000000000000..eadb23490d25f428e66f327023616f5b24c435e4 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Vithkuqi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Wancho.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Wancho.js new file mode 100644 index 0000000000000000000000000000000000000000..777b2b7091f71c5c58c707c92afaf0f57792c32c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Wancho.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1E2FF); +set.addRange(0x1E2C0, 0x1E2F9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Warang_Citi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Warang_Citi.js new file mode 100644 index 0000000000000000000000000000000000000000..8c98bbc26ca3d1a2f0d129ade0cd03649b6de205 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Warang_Citi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x118FF); +set.addRange(0x118A0, 0x118F2); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Yezidi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Yezidi.js new file mode 100644 index 0000000000000000000000000000000000000000..5bda8431ef0edf927d5c8e3d967f81f4210d0baa --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Yezidi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10E80, 0x10EA9).addRange(0x10EAB, 0x10EAD).addRange(0x10EB0, 0x10EB1); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Yi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Yi.js new file mode 100644 index 0000000000000000000000000000000000000000..642e7457488feef4d0707d2796717207ada2d1ff --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Yi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA000, 0xA48C).addRange(0xA490, 0xA4C6); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script/Zanabazar_Square.js b/tools/ui/node_modules/regenerate-unicode-properties/Script/Zanabazar_Square.js new file mode 100644 index 0000000000000000000000000000000000000000..0f4afc629ae7c663b0867e5c2f2f0652e5e84b42 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script/Zanabazar_Square.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11A00, 0x11A47); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Adlam.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Adlam.js new file mode 100644 index 0000000000000000000000000000000000000000..dfa8c344f432754c25d3d7f98d1911a385234c62 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Adlam.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x61F, 0x640, 0x204F, 0x2E41); +set.addRange(0x1E900, 0x1E94B).addRange(0x1E950, 0x1E959).addRange(0x1E95E, 0x1E95F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ahom.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ahom.js new file mode 100644 index 0000000000000000000000000000000000000000..8d904d312292d257b8e2739f27503f94498cbc3d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ahom.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11700, 0x1171A).addRange(0x1171D, 0x1172B).addRange(0x11730, 0x11746); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Anatolian_Hieroglyphs.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Anatolian_Hieroglyphs.js new file mode 100644 index 0000000000000000000000000000000000000000..9a2708580fb08e339512f967aff7a1e7a301ed1e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Anatolian_Hieroglyphs.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x14400, 0x14646); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Arabic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Arabic.js new file mode 100644 index 0000000000000000000000000000000000000000..7b6273a23787d446aa436c85cec70ba8aca58e6b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Arabic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x204F, 0x2E41, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E); +set.addRange(0x600, 0x604).addRange(0x606, 0x6DC).addRange(0x6DE, 0x6FF).addRange(0x750, 0x77F).addRange(0x870, 0x891).addRange(0x897, 0x8E1).addRange(0x8E3, 0x8FF).addRange(0xFB50, 0xFDCF).addRange(0xFDF0, 0xFDFF).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0x102E0, 0x102FB).addRange(0x10E60, 0x10E7E).addRange(0x10EC2, 0x10EC7).addRange(0x10ED0, 0x10ED8).addRange(0x10EFA, 0x10EFF).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1EEF0, 0x1EEF1); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Armenian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Armenian.js new file mode 100644 index 0000000000000000000000000000000000000000..f29348527ccf861557aaf368c03a89bc486f7069 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Armenian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x308); +set.addRange(0x531, 0x556).addRange(0x559, 0x58A).addRange(0x58D, 0x58F).addRange(0xFB13, 0xFB17); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Avestan.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Avestan.js new file mode 100644 index 0000000000000000000000000000000000000000..1817328cc72e310c71c866a0a62c30eda5b81255 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Avestan.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7); +set.addRange(0x2E30, 0x2E31).addRange(0x10B00, 0x10B35).addRange(0x10B39, 0x10B3F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Balinese.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Balinese.js new file mode 100644 index 0000000000000000000000000000000000000000..90a395ea64f673a95857e0687cbad8685f8b5108 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Balinese.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1B00, 0x1B4C).addRange(0x1B4E, 0x1B7F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bamum.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bamum.js new file mode 100644 index 0000000000000000000000000000000000000000..10f96107c46223aa02d3a2dd3bf6348fe13de152 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bamum.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA6A0, 0xA6F7).addRange(0x16800, 0x16A38); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bassa_Vah.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bassa_Vah.js new file mode 100644 index 0000000000000000000000000000000000000000..e98f574d023b2ce57ea0f08529bd66fcd2bf3359 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bassa_Vah.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16AD0, 0x16AED).addRange(0x16AF0, 0x16AF5); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Batak.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Batak.js new file mode 100644 index 0000000000000000000000000000000000000000..8568f97b4dbc14fb4b6439c0252bfbca92cb9309 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Batak.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1BC0, 0x1BF3).addRange(0x1BFC, 0x1BFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bengali.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bengali.js new file mode 100644 index 0000000000000000000000000000000000000000..df187c85888e65cc05d8531f831af99ec4fc6eff --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bengali.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2BC, 0x9B2, 0x9D7, 0x1CD0, 0x1CD2, 0x1CD8, 0x1CE1, 0x1CEA, 0x1CED, 0x1CF2, 0xA8F1); +set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0x980, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BC, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CE).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E3).addRange(0x9E6, 0x9FE).addRange(0x1CD5, 0x1CD6).addRange(0x1CF5, 0x1CF7); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Beria_Erfe.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Beria_Erfe.js new file mode 100644 index 0000000000000000000000000000000000000000..9cdc4b0f5522161ce1593632af6a5abbb3a18b7b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Beria_Erfe.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16EA0, 0x16EB8).addRange(0x16EBB, 0x16ED3); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bhaiksuki.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bhaiksuki.js new file mode 100644 index 0000000000000000000000000000000000000000..be0691819ab850e98c4e595bff911e4df98643ec --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bhaiksuki.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C36).addRange(0x11C38, 0x11C45).addRange(0x11C50, 0x11C6C); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bopomofo.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bopomofo.js new file mode 100644 index 0000000000000000000000000000000000000000..e43a15b133a2c92c41379c8fda8d7f42f359fe32 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Bopomofo.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2C7, 0x2D9, 0x3030, 0x3037, 0x30FB); +set.addRange(0x2C9, 0x2CB).addRange(0x2EA, 0x2EB).addRange(0x3001, 0x3003).addRange(0x3008, 0x3011).addRange(0x3013, 0x301F).addRange(0x302A, 0x302D).addRange(0x3105, 0x312F).addRange(0x31A0, 0x31BF).addRange(0xFE45, 0xFE46).addRange(0xFF61, 0xFF65); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Brahmi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Brahmi.js new file mode 100644 index 0000000000000000000000000000000000000000..9d104df65a0ce0b11c4fdaaa151b8c6a45a965cb --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Brahmi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1107F); +set.addRange(0x11000, 0x1104D).addRange(0x11052, 0x11075); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Braille.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Braille.js new file mode 100644 index 0000000000000000000000000000000000000000..4b6b88fddac828bec3c386872d4f4fdb3225c55e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Braille.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x2800, 0x28FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Buginese.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Buginese.js new file mode 100644 index 0000000000000000000000000000000000000000..b4394507ec9f84e2af42e6d4d8316cea730132d7 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Buginese.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xA9CF); +set.addRange(0x1A00, 0x1A1B).addRange(0x1A1E, 0x1A1F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Buhid.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Buhid.js new file mode 100644 index 0000000000000000000000000000000000000000..aa2c18078aa32a742dcb448add011499d6024157 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Buhid.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1735, 0x1736).addRange(0x1740, 0x1753); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Canadian_Aboriginal.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Canadian_Aboriginal.js new file mode 100644 index 0000000000000000000000000000000000000000..d601f89aced9f2b78f8f8c5ff54c70fe45054553 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Canadian_Aboriginal.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1400, 0x167F).addRange(0x18B0, 0x18F5).addRange(0x11AB0, 0x11ABF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Carian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Carian.js new file mode 100644 index 0000000000000000000000000000000000000000..5f708a188d98bd1c37d1f993b86ca83aeffaaddf --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Carian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7, 0x205A, 0x205D, 0x2E31); +set.addRange(0x102A0, 0x102D0); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Caucasian_Albanian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Caucasian_Albanian.js new file mode 100644 index 0000000000000000000000000000000000000000..b61d771f664d051d470fc74a2f83bb42ada25b7c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Caucasian_Albanian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x304, 0x331, 0x35E, 0x1056F); +set.addRange(0x10530, 0x10563); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Chakma.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Chakma.js new file mode 100644 index 0000000000000000000000000000000000000000..b03cb0b21c6a9e796f16df6e409d8b29c900ac98 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Chakma.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x9E6, 0x9EF).addRange(0x1040, 0x1049).addRange(0x11100, 0x11134).addRange(0x11136, 0x11147); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cham.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cham.js new file mode 100644 index 0000000000000000000000000000000000000000..6d5304bb6b8fccea848c68a690f43e83c400ddac --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cham.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xAA00, 0xAA36).addRange(0xAA40, 0xAA4D).addRange(0xAA50, 0xAA59).addRange(0xAA5C, 0xAA5F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cherokee.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cherokee.js new file mode 100644 index 0000000000000000000000000000000000000000..9ab0b03122150362fe3bbbf51b88c6b8c5fa502a --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cherokee.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x304); +set.addRange(0x300, 0x302).addRange(0x30B, 0x30C).addRange(0x323, 0x324).addRange(0x330, 0x331).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0xAB70, 0xABBF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Chorasmian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Chorasmian.js new file mode 100644 index 0000000000000000000000000000000000000000..5d56367bdc69d555a7ca00e381bf0773a89e7752 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Chorasmian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10FB0, 0x10FCB); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Common.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Common.js new file mode 100644 index 0000000000000000000000000000000000000000..642f4364df73a98ba12eb0a6feccd1b05ba41901 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Common.js @@ -0,0 +1,5 @@ +const set = require('regenerate')(0xD7, 0xF7, 0x2C8, 0x2CC, 0x2D8, 0x37E, 0x385, 0x387, 0x605, 0x6DD, 0x8E2, 0xE3F, 0x2E42, 0x3000, 0x3004, 0x3012, 0x3020, 0x3036, 0x327F, 0x33FF, 0xAB5B, 0xFEFF, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1F7F0, 0x1FAC8, 0xE0001); +set.addRange(0x0, 0x40).addRange(0x5B, 0x60).addRange(0x7B, 0xA9).addRange(0xAB, 0xB6).addRange(0xB8, 0xB9).addRange(0xBB, 0xBF).addRange(0x2B9, 0x2BB).addRange(0x2BD, 0x2C6).addRange(0x2CE, 0x2D6).addRange(0x2DA, 0x2DF).addRange(0x2E5, 0x2E9).addRange(0x2EC, 0x2FF).addRange(0xFD5, 0xFD8).addRange(0x2000, 0x200B).addRange(0x200E, 0x202E).addRange(0x2030, 0x204E).addRange(0x2050, 0x2059).addRange(0x205B, 0x205C).addRange(0x205E, 0x2064).addRange(0x2066, 0x2070).addRange(0x2074, 0x207E).addRange(0x2080, 0x208E).addRange(0x20A0, 0x20C1).addRange(0x2100, 0x2125).addRange(0x2127, 0x2129).addRange(0x212C, 0x2131).addRange(0x2133, 0x214D).addRange(0x214F, 0x215F).addRange(0x2189, 0x218B).addRange(0x2190, 0x2429).addRange(0x2440, 0x244A).addRange(0x2460, 0x27FF).addRange(0x2900, 0x2B73).addRange(0x2B76, 0x2BFF).addRange(0x2E00, 0x2E16).addRange(0x2E18, 0x2E2F).addRange(0x2E32, 0x2E3B).addRange(0x2E3D, 0x2E40).addRange(0x2E44, 0x2E5D).addRange(0x3248, 0x325F).addRange(0x32B1, 0x32BF).addRange(0x32CC, 0x32CF).addRange(0x3371, 0x337A).addRange(0x3380, 0x33DF).addRange(0x4DC0, 0x4DFF).addRange(0xA708, 0xA721).addRange(0xA788, 0xA78A).addRange(0xAB6A, 0xAB6B).addRange(0xFE10, 0xFE19).addRange(0xFE30, 0xFE44).addRange(0xFE47, 0xFE52); +set.addRange(0xFE54, 0xFE66).addRange(0xFE68, 0xFE6B).addRange(0xFF01, 0xFF20).addRange(0xFF3B, 0xFF40).addRange(0xFF5B, 0xFF60).addRange(0xFFE0, 0xFFE6).addRange(0xFFE8, 0xFFEE).addRange(0xFFF9, 0xFFFD).addRange(0x10190, 0x1019C).addRange(0x101D0, 0x101FC).addRange(0x1CC00, 0x1CCFC).addRange(0x1CD00, 0x1CEB3).addRange(0x1CEBA, 0x1CED0).addRange(0x1CEE0, 0x1CEF0).addRange(0x1CF50, 0x1CFC3).addRange(0x1D000, 0x1D0F5).addRange(0x1D100, 0x1D126).addRange(0x1D129, 0x1D166).addRange(0x1D16A, 0x1D17A).addRange(0x1D183, 0x1D184).addRange(0x1D18C, 0x1D1A9).addRange(0x1D1AE, 0x1D1EA).addRange(0x1D2C0, 0x1D2D3).addRange(0x1D2E0, 0x1D2F3).addRange(0x1D300, 0x1D356).addRange(0x1D372, 0x1D378).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D7CB).addRange(0x1D7CE, 0x1D7FF).addRange(0x1EC71, 0x1ECB4).addRange(0x1ED01, 0x1ED3D).addRange(0x1F000, 0x1F02B).addRange(0x1F030, 0x1F093).addRange(0x1F0A0, 0x1F0AE).addRange(0x1F0B1, 0x1F0BF).addRange(0x1F0C1, 0x1F0CF); +set.addRange(0x1F0D1, 0x1F0F5).addRange(0x1F100, 0x1F1AD).addRange(0x1F1E6, 0x1F1FF).addRange(0x1F201, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F260, 0x1F265).addRange(0x1F300, 0x1F6D8).addRange(0x1F6DC, 0x1F6EC).addRange(0x1F6F0, 0x1F6FC).addRange(0x1F700, 0x1F7D9).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F800, 0x1F80B).addRange(0x1F810, 0x1F847).addRange(0x1F850, 0x1F859).addRange(0x1F860, 0x1F887).addRange(0x1F890, 0x1F8AD).addRange(0x1F8B0, 0x1F8BB).addRange(0x1F8C0, 0x1F8C1).addRange(0x1F8D0, 0x1F8D8).addRange(0x1F900, 0x1FA57).addRange(0x1FA60, 0x1FA6D).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA8A).addRange(0x1FA8E, 0x1FAC6).addRange(0x1FACD, 0x1FADC).addRange(0x1FADF, 0x1FAEA).addRange(0x1FAEF, 0x1FAF8).addRange(0x1FB00, 0x1FB92).addRange(0x1FB94, 0x1FBFA).addRange(0xE0020, 0xE007F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Coptic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Coptic.js new file mode 100644 index 0000000000000000000000000000000000000000..33004cc5563ef7cedbf4dc624a25f005e68a1f9b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Coptic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7, 0x300, 0x307, 0x2E17); +set.addRange(0x304, 0x305).addRange(0x374, 0x375).addRange(0x3E2, 0x3EF).addRange(0x2C80, 0x2CF3).addRange(0x2CF9, 0x2CFF).addRange(0x102E0, 0x102FB); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cuneiform.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cuneiform.js new file mode 100644 index 0000000000000000000000000000000000000000..1d4da572254e5734c189bdbc504510c81053c708 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cuneiform.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12470, 0x12474).addRange(0x12480, 0x12543); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cypriot.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cypriot.js new file mode 100644 index 0000000000000000000000000000000000000000..9330f47286b69af2a9ff5ffbbaa1aa47d40e977b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cypriot.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x10808, 0x1083C, 0x1083F); +set.addRange(0x10100, 0x10102).addRange(0x10107, 0x10133).addRange(0x10137, 0x1013F).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cypro_Minoan.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cypro_Minoan.js new file mode 100644 index 0000000000000000000000000000000000000000..0fd5164745cad3d41f61e380d3967ccb55a8fa23 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cypro_Minoan.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10100, 0x10101).addRange(0x12F90, 0x12FF2); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cyrillic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cyrillic.js new file mode 100644 index 0000000000000000000000000000000000000000..c7e019e26566d79004fbfcbceffafe0e700bad9a --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Cyrillic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2BC, 0x304, 0x306, 0x308, 0x30B, 0x311, 0x1D2B, 0x1D78, 0x1DF8, 0x2E43, 0x1E08F); +set.addRange(0x300, 0x302).addRange(0x400, 0x52F).addRange(0x1C80, 0x1C8A).addRange(0x2DE0, 0x2DFF).addRange(0xA640, 0xA69F).addRange(0xFE2E, 0xFE2F).addRange(0x1E030, 0x1E06D); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Deseret.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Deseret.js new file mode 100644 index 0000000000000000000000000000000000000000..068648351317f8d65b3d397e0217bd6a16da1221 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Deseret.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10400, 0x1044F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Devanagari.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Devanagari.js new file mode 100644 index 0000000000000000000000000000000000000000..79447c0379018252e2884f2097edfeaf7209a8e5 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Devanagari.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2BC, 0x20F0); +set.addRange(0x900, 0x952).addRange(0x955, 0x97F).addRange(0x1CD0, 0x1CF6).addRange(0x1CF8, 0x1CF9).addRange(0xA830, 0xA839).addRange(0xA8E0, 0xA8FF).addRange(0x11B00, 0x11B09); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Dives_Akuru.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Dives_Akuru.js new file mode 100644 index 0000000000000000000000000000000000000000..242d20a32def11bd2ffbf9589939f16111a30269 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Dives_Akuru.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x11909); +set.addRange(0x11900, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x11946).addRange(0x11950, 0x11959); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Dogra.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Dogra.js new file mode 100644 index 0000000000000000000000000000000000000000..04fb30dc124e59cbab9925ecb5c2187a26e4186f --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Dogra.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x964, 0x96F).addRange(0xA830, 0xA839).addRange(0x11800, 0x1183B); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Duployan.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Duployan.js new file mode 100644 index 0000000000000000000000000000000000000000..cf2916055bdbb718bfffca527731ca5fa58442ea --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Duployan.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7, 0x30A, 0x2E3C); +set.addRange(0x307, 0x308).addRange(0x323, 0x324).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1BC9C, 0x1BCA3); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Egyptian_Hieroglyphs.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Egyptian_Hieroglyphs.js new file mode 100644 index 0000000000000000000000000000000000000000..e2fcdc8000e18221c4e1736f5ba3f71e3285c60b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Egyptian_Hieroglyphs.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x13000, 0x13455).addRange(0x13460, 0x143FA); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Elbasan.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Elbasan.js new file mode 100644 index 0000000000000000000000000000000000000000..8f0765d7ddf0d50c766f3744aca6c66873075634 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Elbasan.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7, 0x305); +set.addRange(0x10500, 0x10527); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Elymaic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Elymaic.js new file mode 100644 index 0000000000000000000000000000000000000000..1481d0b47a69308c337517fd6e2209470bd7ab40 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Elymaic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10FE0, 0x10FF6); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ethiopic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ethiopic.js new file mode 100644 index 0000000000000000000000000000000000000000..9fc7abd182b1d518c6c2b215242eaca73667a0fb --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ethiopic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x30E, 0x1258, 0x12C0); +set.addRange(0x1200, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x135D, 0x137C).addRange(0x1380, 0x1399).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Garay.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Garay.js new file mode 100644 index 0000000000000000000000000000000000000000..90c2b2b633884c99d8189542ab3439e2e9f27bbc --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Garay.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x60C, 0x61B, 0x61F); +set.addRange(0x10D40, 0x10D65).addRange(0x10D69, 0x10D85).addRange(0x10D8E, 0x10D8F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Georgian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Georgian.js new file mode 100644 index 0000000000000000000000000000000000000000..19c979618d9f3f966c3f8a839e0551396ed9f4e7 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Georgian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7, 0x589, 0x10C7, 0x10CD, 0x205A, 0x2D27, 0x2D2D, 0x2E31); +set.addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FF).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x2D00, 0x2D25); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Glagolitic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Glagolitic.js new file mode 100644 index 0000000000000000000000000000000000000000..2251312a0d20d5da80a5af10d25b574ae0547293 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Glagolitic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7, 0x303, 0x305, 0x484, 0x487, 0x589, 0x10FB, 0x205A, 0x2E43, 0xA66F); +set.addRange(0x2C00, 0x2C5F).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gothic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gothic.js new file mode 100644 index 0000000000000000000000000000000000000000..c54f806a06510a77738712c9976b3e7c48340357 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gothic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7, 0x308, 0x331); +set.addRange(0x304, 0x305).addRange(0x10330, 0x1034A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Grantha.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Grantha.js new file mode 100644 index 0000000000000000000000000000000000000000..ec12cbec625b7f00427d6bd2670d59667be73086 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Grantha.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1CD0, 0x20F0, 0x11350, 0x11357, 0x11FD3); +set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xBE6, 0xBF3).addRange(0x1CD2, 0x1CD3).addRange(0x1CF2, 0x1CF4).addRange(0x1CF8, 0x1CF9).addRange(0x11300, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1133B, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x1135D, 0x11363).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x11FD0, 0x11FD1); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Greek.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Greek.js new file mode 100644 index 0000000000000000000000000000000000000000..bf54c04744f247db3281bc7cf4db27aa388fdf31 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Greek.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7, 0x304, 0x306, 0x308, 0x313, 0x342, 0x345, 0x37F, 0x384, 0x386, 0x38C, 0x1F59, 0x1F5B, 0x1F5D, 0x205D, 0x2126, 0xAB65, 0x101A0); +set.addRange(0x300, 0x301).addRange(0x370, 0x377).addRange(0x37A, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3E1).addRange(0x3F0, 0x3FF).addRange(0x1D26, 0x1D2A).addRange(0x1D5D, 0x1D61).addRange(0x1D66, 0x1D6A).addRange(0x1DBF, 0x1DC1).addRange(0x1F00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FC4).addRange(0x1FC6, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FDD, 0x1FEF).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFE).addRange(0x10140, 0x1018E).addRange(0x1D200, 0x1D245); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gujarati.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gujarati.js new file mode 100644 index 0000000000000000000000000000000000000000..e84d48da8ad9071d1324539127a38f09c451b3b3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gujarati.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xAD0); +set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xA81, 0xA83).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABC, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACD).addRange(0xAE0, 0xAE3).addRange(0xAE6, 0xAF1).addRange(0xAF9, 0xAFF).addRange(0xA830, 0xA839); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gunjala_Gondi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gunjala_Gondi.js new file mode 100644 index 0000000000000000000000000000000000000000..4fe286e5c9a65e8bef1da191834ba8adcf906ee8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gunjala_Gondi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7); +set.addRange(0x964, 0x965).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D98).addRange(0x11DA0, 0x11DA9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gurmukhi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gurmukhi.js new file mode 100644 index 0000000000000000000000000000000000000000..8040c1cbfa564f2fde9729520aaa520ba878b4d6 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gurmukhi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xA3C, 0xA51, 0xA5E); +set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xA01, 0xA03).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA59, 0xA5C).addRange(0xA66, 0xA76).addRange(0xA830, 0xA839); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gurung_Khema.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gurung_Khema.js new file mode 100644 index 0000000000000000000000000000000000000000..3540a0186a0d9807f09e8989dd827a639edc37a0 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Gurung_Khema.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x965); +set.addRange(0x16100, 0x16139); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Han.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Han.js new file mode 100644 index 0000000000000000000000000000000000000000..5c65551e5bc2b53f393b12506a3ff45681fa05d2 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Han.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7, 0x3030, 0x30FB, 0x31EF, 0x32FF); +set.addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5).addRange(0x2FF0, 0x2FFF).addRange(0x3001, 0x3003).addRange(0x3005, 0x3011).addRange(0x3013, 0x301F).addRange(0x3021, 0x302D).addRange(0x3037, 0x303F).addRange(0x3190, 0x319F).addRange(0x31C0, 0x31E5).addRange(0x3220, 0x3247).addRange(0x3280, 0x32B0).addRange(0x32C0, 0x32CB).addRange(0x3358, 0x3370).addRange(0x337B, 0x337F).addRange(0x33E0, 0x33FE).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0x9FFF).addRange(0xA700, 0xA707).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFE45, 0xFE46).addRange(0xFF61, 0xFF65).addRange(0x16FE2, 0x16FE3).addRange(0x16FF0, 0x16FF6).addRange(0x1D360, 0x1D371).addRange(0x1F250, 0x1F251).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B81D).addRange(0x2B820, 0x2CEAD).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x33479); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hangul.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hangul.js new file mode 100644 index 0000000000000000000000000000000000000000..a331f8a75eaee492277b0bfe4dc1edaf01a384ad --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hangul.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x3037, 0x30FB); +set.addRange(0x1100, 0x11FF).addRange(0x3001, 0x3003).addRange(0x3008, 0x3011).addRange(0x3013, 0x301F).addRange(0x302E, 0x3030).addRange(0x3131, 0x318E).addRange(0x3200, 0x321E).addRange(0x3260, 0x327E).addRange(0xA960, 0xA97C).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xFE45, 0xFE46).addRange(0xFF61, 0xFF65).addRange(0xFFA0, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hanifi_Rohingya.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hanifi_Rohingya.js new file mode 100644 index 0000000000000000000000000000000000000000..8cd79eb49e5a6f215fb5ab07ac68b45023f3df30 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hanifi_Rohingya.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x60C, 0x61B, 0x61F, 0x640, 0x6D4); +set.addRange(0x10D00, 0x10D27).addRange(0x10D30, 0x10D39); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hanunoo.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hanunoo.js new file mode 100644 index 0000000000000000000000000000000000000000..e21a438f1b24a57df18a5b8c004aa11ad714ee91 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hanunoo.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1720, 0x1736); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hatran.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hatran.js new file mode 100644 index 0000000000000000000000000000000000000000..2a21cfde04686a091587cc949d1fc2400e4a2023 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hatran.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x108FB, 0x108FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hebrew.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hebrew.js new file mode 100644 index 0000000000000000000000000000000000000000..1ac3f7d679944455eca8bda90ad9e22019956742 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hebrew.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xFB3E); +set.addRange(0x307, 0x308).addRange(0x591, 0x5C7).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F4).addRange(0xFB1D, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFB4F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hiragana.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hiragana.js new file mode 100644 index 0000000000000000000000000000000000000000..8039e96cece04cb6db48d06c73a6e833a47dc40d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Hiragana.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x3037, 0xFF70, 0x1B132, 0x1F200); +set.addRange(0x3001, 0x3003).addRange(0x3008, 0x3011).addRange(0x3013, 0x301F).addRange(0x3030, 0x3035).addRange(0x303C, 0x303D).addRange(0x3041, 0x3096).addRange(0x3099, 0x30A0).addRange(0x30FB, 0x30FC).addRange(0xFE45, 0xFE46).addRange(0xFF61, 0xFF65).addRange(0xFF9E, 0xFF9F).addRange(0x1B001, 0x1B11F).addRange(0x1B150, 0x1B152); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Imperial_Aramaic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Imperial_Aramaic.js new file mode 100644 index 0000000000000000000000000000000000000000..eb30687960acb069695a2424be96fd8608b324d3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Imperial_Aramaic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10840, 0x10855).addRange(0x10857, 0x1085F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Inherited.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Inherited.js new file mode 100644 index 0000000000000000000000000000000000000000..169b46f6fa94f79d74ac87c35a9bf7203e0b7189 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Inherited.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x30F, 0x312, 0x32F, 0x1DF9, 0x101FD); +set.addRange(0x314, 0x322).addRange(0x326, 0x32C).addRange(0x332, 0x341).addRange(0x343, 0x344).addRange(0x346, 0x357).addRange(0x359, 0x35D).addRange(0x35F, 0x362).addRange(0x953, 0x954).addRange(0x1AB0, 0x1ADD).addRange(0x1AE0, 0x1AEB).addRange(0x1DC2, 0x1DF7).addRange(0x1DFB, 0x1DFF).addRange(0x200C, 0x200D).addRange(0x20D0, 0x20EF).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2D).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D167, 0x1D169).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0xE0100, 0xE01EF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Inscriptional_Pahlavi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Inscriptional_Pahlavi.js new file mode 100644 index 0000000000000000000000000000000000000000..ae7dd10d16d0441d48aad8389b85fe3a5a5e0552 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Inscriptional_Pahlavi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10B60, 0x10B72).addRange(0x10B78, 0x10B7F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Inscriptional_Parthian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Inscriptional_Parthian.js new file mode 100644 index 0000000000000000000000000000000000000000..decc12d8d31ee38485036523bec22e712b101fe3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Inscriptional_Parthian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10B40, 0x10B55).addRange(0x10B58, 0x10B5F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Javanese.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Javanese.js new file mode 100644 index 0000000000000000000000000000000000000000..59bd036c4419866d05a6c83531f3157f2c8c1a0f --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Javanese.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA980, 0xA9CD).addRange(0xA9CF, 0xA9D9).addRange(0xA9DE, 0xA9DF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kaithi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kaithi.js new file mode 100644 index 0000000000000000000000000000000000000000..95da2827b0cfc451715a1cc545a9bbc698ce8d84 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kaithi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2E31, 0x110CD); +set.addRange(0x966, 0x96F).addRange(0xA830, 0xA839).addRange(0x11080, 0x110C2); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kannada.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kannada.js new file mode 100644 index 0000000000000000000000000000000000000000..3b01dcb6a40eafacddf23293d453c40c809645c5 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kannada.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1CD0, 0x1CDA, 0x1CF2, 0x1CF4); +set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xC80, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCBC, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCDC, 0xCDE).addRange(0xCE0, 0xCE3).addRange(0xCE6, 0xCEF).addRange(0xCF1, 0xCF3).addRange(0x1CD2, 0x1CD3).addRange(0xA830, 0xA835); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Katakana.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Katakana.js new file mode 100644 index 0000000000000000000000000000000000000000..569f51a4d7bc6c4d260053b14fe69af89ee70240 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Katakana.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x305, 0x323, 0x3037, 0x1B000, 0x1B155); +set.addRange(0x3001, 0x3003).addRange(0x3008, 0x3011).addRange(0x3013, 0x301F).addRange(0x3030, 0x3035).addRange(0x303C, 0x303D).addRange(0x3099, 0x309C).addRange(0x30A0, 0x30FF).addRange(0x31F0, 0x31FF).addRange(0x32D0, 0x32FE).addRange(0x3300, 0x3357).addRange(0xFE45, 0xFE46).addRange(0xFF61, 0xFF9F).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B120, 0x1B122).addRange(0x1B164, 0x1B167); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kawi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kawi.js new file mode 100644 index 0000000000000000000000000000000000000000..c306305d0071c279dd1dc278fbe9f481b2aa918c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kawi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11F00, 0x11F10).addRange(0x11F12, 0x11F3A).addRange(0x11F3E, 0x11F5A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kayah_Li.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kayah_Li.js new file mode 100644 index 0000000000000000000000000000000000000000..3497a996ce993e756ded1006a9ff4ccc738c2130 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kayah_Li.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA900, 0xA92F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kharoshthi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kharoshthi.js new file mode 100644 index 0000000000000000000000000000000000000000..10f07e4b7c91a55739fc56b408370a09632a7f34 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kharoshthi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10A00, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A38, 0x10A3A).addRange(0x10A3F, 0x10A48).addRange(0x10A50, 0x10A58); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Khitan_Small_Script.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Khitan_Small_Script.js new file mode 100644 index 0000000000000000000000000000000000000000..fda2548cd94c5524b4de6eacc714534001b6487c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Khitan_Small_Script.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x16FE4, 0x18CFF); +set.addRange(0x18B00, 0x18CD5); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Khmer.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Khmer.js new file mode 100644 index 0000000000000000000000000000000000000000..e15f4e3cc8d92a44dd189ce617855998bdacc4ec --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Khmer.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1780, 0x17DD).addRange(0x17E0, 0x17E9).addRange(0x17F0, 0x17F9).addRange(0x19E0, 0x19FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Khojki.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Khojki.js new file mode 100644 index 0000000000000000000000000000000000000000..38bdc83a6c7eec9e7b7d9488f1066dff39d920df --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Khojki.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xAE6, 0xAEF).addRange(0xA830, 0xA839).addRange(0x11200, 0x11211).addRange(0x11213, 0x11241); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Khudawadi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Khudawadi.js new file mode 100644 index 0000000000000000000000000000000000000000..c3fa738f25b94622000af10e717f6557dae96c6e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Khudawadi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x964, 0x965).addRange(0xA830, 0xA839).addRange(0x112B0, 0x112EA).addRange(0x112F0, 0x112F9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kirat_Rai.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kirat_Rai.js new file mode 100644 index 0000000000000000000000000000000000000000..261dcd253dadefd1dfeb9089a83c8472b64ef2b8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Kirat_Rai.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16D40, 0x16D79); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lao.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lao.js new file mode 100644 index 0000000000000000000000000000000000000000..7b4a7d94dcbc8bb091105e9c84e07a09e92e66d9 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lao.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xE84, 0xEA5, 0xEC6); +set.addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEBD).addRange(0xEC0, 0xEC4).addRange(0xEC8, 0xECE).addRange(0xED0, 0xED9).addRange(0xEDC, 0xEDF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Latin.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Latin.js new file mode 100644 index 0000000000000000000000000000000000000000..10e8cf65812ba2cca90c3c4876adc91e2c1b8867 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Latin.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xAA, 0xB7, 0xBA, 0x2BC, 0x2C7, 0x2CD, 0x2D7, 0x2D9, 0x313, 0x358, 0x35E, 0x10FB, 0x1DF8, 0x202F, 0x2071, 0x207F, 0x20F0, 0x2132, 0x214E, 0x2E17, 0xA92E); +set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2B8).addRange(0x2C9, 0x2CB).addRange(0x2E0, 0x2E4).addRange(0x300, 0x30E).addRange(0x310, 0x311).addRange(0x323, 0x325).addRange(0x32D, 0x32E).addRange(0x330, 0x331).addRange(0x363, 0x36F).addRange(0x485, 0x486).addRange(0x951, 0x952).addRange(0x1D00, 0x1D25).addRange(0x1D2C, 0x1D5C).addRange(0x1D62, 0x1D65).addRange(0x1D6B, 0x1D77).addRange(0x1D79, 0x1DBE).addRange(0x1E00, 0x1EFF).addRange(0x2090, 0x209C).addRange(0x212A, 0x212B).addRange(0x2160, 0x2188).addRange(0x2C60, 0x2C7F).addRange(0xA700, 0xA707).addRange(0xA722, 0xA787).addRange(0xA78B, 0xA7DC).addRange(0xA7F1, 0xA7FF).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB64).addRange(0xAB66, 0xAB69).addRange(0xFB00, 0xFB06).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lepcha.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lepcha.js new file mode 100644 index 0000000000000000000000000000000000000000..3a495e6666578f0c65b6e3fc20f0ed28bf9b1f07 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lepcha.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1C00, 0x1C37).addRange(0x1C3B, 0x1C49).addRange(0x1C4D, 0x1C4F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Limbu.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Limbu.js new file mode 100644 index 0000000000000000000000000000000000000000..56f022fdca854ae3de7884663590bcf202218285 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Limbu.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x965, 0x1940); +set.addRange(0x1900, 0x191E).addRange(0x1920, 0x192B).addRange(0x1930, 0x193B).addRange(0x1944, 0x194F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Linear_A.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Linear_A.js new file mode 100644 index 0000000000000000000000000000000000000000..ea40b0aee241d46a03549dd1578110aeca6b3c35 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Linear_A.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10107, 0x10133).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Linear_B.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Linear_B.js new file mode 100644 index 0000000000000000000000000000000000000000..30c803964696b7c879c90fa055b801f7ce7e76e0 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Linear_B.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10100, 0x10102).addRange(0x10107, 0x10133).addRange(0x10137, 0x1013F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lisu.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lisu.js new file mode 100644 index 0000000000000000000000000000000000000000..b8dc0317c68ce262f85d82a29e3ad596d237a565 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lisu.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2BC, 0x2CD, 0x11FB0); +set.addRange(0x300A, 0x300B).addRange(0xA4D0, 0xA4FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lycian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lycian.js new file mode 100644 index 0000000000000000000000000000000000000000..6d1b51053e6ed87deaba798746b540a0ea98905a --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lycian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x205A); +set.addRange(0x10280, 0x1029C); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lydian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lydian.js new file mode 100644 index 0000000000000000000000000000000000000000..e595c8f6f78ca542d3f1b47aeda0b45e3a3bcb15 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Lydian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7, 0x2E31, 0x1093F); +set.addRange(0x10920, 0x10939); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mahajani.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mahajani.js new file mode 100644 index 0000000000000000000000000000000000000000..cb04518a3ccc5d900757c79e16e7bdb7533ef71c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mahajani.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7); +set.addRange(0x964, 0x96F).addRange(0xA830, 0xA839).addRange(0x11150, 0x11176); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Makasar.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Makasar.js new file mode 100644 index 0000000000000000000000000000000000000000..498a157caefbf4bd385fdca670339b2d6cb06a3f --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Makasar.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11EE0, 0x11EF8); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Malayalam.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Malayalam.js new file mode 100644 index 0000000000000000000000000000000000000000..252563eb41dd1fe0384c22a2457695a21dc7b25c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Malayalam.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1CDA, 0x1CF2); +set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xD00, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4F).addRange(0xD54, 0xD63).addRange(0xD66, 0xD7F).addRange(0xA830, 0xA832); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mandaic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mandaic.js new file mode 100644 index 0000000000000000000000000000000000000000..e330539745aa9e2c969131fbdbf892ff9aa0be83 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mandaic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x640, 0x85E); +set.addRange(0x840, 0x85B); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Manichaean.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Manichaean.js new file mode 100644 index 0000000000000000000000000000000000000000..3db02be7f2e0330335490869608411ea87c9039c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Manichaean.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x640); +set.addRange(0x10AC0, 0x10AE6).addRange(0x10AEB, 0x10AF6); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Marchen.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Marchen.js new file mode 100644 index 0000000000000000000000000000000000000000..08b94ce4e9bc21a49028efc8721f0dec190f00bd --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Marchen.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11C70, 0x11C8F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Masaram_Gondi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Masaram_Gondi.js new file mode 100644 index 0000000000000000000000000000000000000000..14d9511906bc4985fcf94656b0044c0be2153836 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Masaram_Gondi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x11D3A); +set.addRange(0x964, 0x965).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D47).addRange(0x11D50, 0x11D59); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Medefaidrin.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Medefaidrin.js new file mode 100644 index 0000000000000000000000000000000000000000..d99281c2ad7eccb0dd9da4ccd69be3c52fe7cba6 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Medefaidrin.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16E40, 0x16E9A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Meetei_Mayek.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Meetei_Mayek.js new file mode 100644 index 0000000000000000000000000000000000000000..247ad69801134341b576d9253428416290baa852 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Meetei_Mayek.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xAAE0, 0xAAF6).addRange(0xABC0, 0xABED).addRange(0xABF0, 0xABF9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mende_Kikakui.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mende_Kikakui.js new file mode 100644 index 0000000000000000000000000000000000000000..a451df7986d68a439ffbfe8c62da0d4753f0dba9 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mende_Kikakui.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1E800, 0x1E8C4).addRange(0x1E8C7, 0x1E8D6); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Meroitic_Cursive.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Meroitic_Cursive.js new file mode 100644 index 0000000000000000000000000000000000000000..e885fe749d410b6fbe0c87a09331abd3f8eb5820 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Meroitic_Cursive.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x109A0, 0x109B7).addRange(0x109BC, 0x109CF).addRange(0x109D2, 0x109FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Meroitic_Hieroglyphs.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Meroitic_Hieroglyphs.js new file mode 100644 index 0000000000000000000000000000000000000000..d1dbe79b2583aa0b2a4513c89f264193fcfe3a07 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Meroitic_Hieroglyphs.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x205D); +set.addRange(0x10980, 0x1099F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Miao.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Miao.js new file mode 100644 index 0000000000000000000000000000000000000000..d6fba56e72148c5b032d30909c5bd140bb5af4e0 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Miao.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16F00, 0x16F4A).addRange(0x16F4F, 0x16F87).addRange(0x16F8F, 0x16F9F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Modi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Modi.js new file mode 100644 index 0000000000000000000000000000000000000000..8fb5409e23e6ddd7c7730dfa6b99a868554e1682 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Modi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA830, 0xA839).addRange(0x11600, 0x11644).addRange(0x11650, 0x11659); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mongolian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mongolian.js new file mode 100644 index 0000000000000000000000000000000000000000..1babb13e63c8428b2fd057ced826ffeca9bd1b6d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mongolian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x202F); +set.addRange(0x1800, 0x1819).addRange(0x1820, 0x1878).addRange(0x1880, 0x18AA).addRange(0x3001, 0x3002).addRange(0x3008, 0x300B).addRange(0x11660, 0x1166C); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mro.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mro.js new file mode 100644 index 0000000000000000000000000000000000000000..4789836987030754d3a2f519a2f72d1f55134a1e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Mro.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16A40, 0x16A5E).addRange(0x16A60, 0x16A69).addRange(0x16A6E, 0x16A6F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Multani.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Multani.js new file mode 100644 index 0000000000000000000000000000000000000000..712f204cbe02827b07f3ec558dea0b8e7269c36d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Multani.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x11288); +set.addRange(0xA66, 0xA6F).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Myanmar.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Myanmar.js new file mode 100644 index 0000000000000000000000000000000000000000..b986c5762a2f7857f2dbd4444b0277d1f1dcc84b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Myanmar.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xA92E); +set.addRange(0x1000, 0x109F).addRange(0xA9E0, 0xA9FE).addRange(0xAA60, 0xAA7F).addRange(0x116D0, 0x116E3); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nabataean.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nabataean.js new file mode 100644 index 0000000000000000000000000000000000000000..5aed2692d0de876d09779f1f5aeefe3b5f314a8d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nabataean.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10880, 0x1089E).addRange(0x108A7, 0x108AF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nag_Mundari.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nag_Mundari.js new file mode 100644 index 0000000000000000000000000000000000000000..1e32d9ac5970eddf68971bf9db0d905dec6e2ece --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nag_Mundari.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1E4D0, 0x1E4F9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nandinagari.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nandinagari.js new file mode 100644 index 0000000000000000000000000000000000000000..90272046621920f13b840eb94661a672a6946562 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nandinagari.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x951, 0x1CE9, 0x1CF2, 0x1CFA); +set.addRange(0x964, 0x965).addRange(0xCE6, 0xCEF).addRange(0xA830, 0xA835).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D7).addRange(0x119DA, 0x119E4); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/New_Tai_Lue.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/New_Tai_Lue.js new file mode 100644 index 0000000000000000000000000000000000000000..27e20dc4c59cbc9d871379f6e310ef5bdea05ffb --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/New_Tai_Lue.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x19D0, 0x19DA).addRange(0x19DE, 0x19DF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Newa.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Newa.js new file mode 100644 index 0000000000000000000000000000000000000000..dc25b000e123d8393c6bc6fb36f3996121062317 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Newa.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1CD5, 0x1CE2, 0x1CE9, 0x1CEB, 0x1CED); +set.addRange(0x951, 0x952).addRange(0x1CD7, 0x1CD8).addRange(0x11400, 0x1145B).addRange(0x1145D, 0x11461); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nko.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nko.js new file mode 100644 index 0000000000000000000000000000000000000000..78d215a640797b518249ddb2d72d6f1a7cd43a3f --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nko.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x60C, 0x61B, 0x61F); +set.addRange(0x7C0, 0x7FA).addRange(0x7FD, 0x7FF).addRange(0xFD3E, 0xFD3F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nushu.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nushu.js new file mode 100644 index 0000000000000000000000000000000000000000..4183de5ffc85999c66ad23cbcce4690c3e1cdea0 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nushu.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x16FE1); +set.addRange(0x1B170, 0x1B2FB); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nyiakeng_Puachue_Hmong.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nyiakeng_Puachue_Hmong.js new file mode 100644 index 0000000000000000000000000000000000000000..dcf75e7d33ce36e270548bb321e592437934d375 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Nyiakeng_Puachue_Hmong.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1E100, 0x1E12C).addRange(0x1E130, 0x1E13D).addRange(0x1E140, 0x1E149).addRange(0x1E14E, 0x1E14F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ogham.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ogham.js new file mode 100644 index 0000000000000000000000000000000000000000..899a9f78a761d9ea626860c3ed9daf1bfb62c27e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ogham.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1680, 0x169C); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ol_Chiki.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ol_Chiki.js new file mode 100644 index 0000000000000000000000000000000000000000..73e64c3e64f795e3416ffea6a34679228d8e14f8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ol_Chiki.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1C50, 0x1C7F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ol_Onal.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ol_Onal.js new file mode 100644 index 0000000000000000000000000000000000000000..747db44ad867e47a14e60742b25af1c0da29e49b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ol_Onal.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1E5FF); +set.addRange(0x964, 0x965).addRange(0x1E5D0, 0x1E5FA); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Hungarian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Hungarian.js new file mode 100644 index 0000000000000000000000000000000000000000..5ec35bfeca2a90010cdc99d438fc89a316a194e2 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Hungarian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x205A, 0x205D, 0x2E31, 0x2E41); +set.addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10CFA, 0x10CFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Italic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Italic.js new file mode 100644 index 0000000000000000000000000000000000000000..41a375afbf7adedebe1442de1f3eb9553b22bc6c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Italic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10300, 0x10323).addRange(0x1032D, 0x1032F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_North_Arabian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_North_Arabian.js new file mode 100644 index 0000000000000000000000000000000000000000..d7c513e113c0460b6fcf0b5fb6922c06d51f9123 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_North_Arabian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10A80, 0x10A9F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Permic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Permic.js new file mode 100644 index 0000000000000000000000000000000000000000..e65f1004016135fa5ee2a3ac39285e550654d3ad --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Permic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7, 0x300, 0x313, 0x483); +set.addRange(0x306, 0x308).addRange(0x10350, 0x1037A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Persian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Persian.js new file mode 100644 index 0000000000000000000000000000000000000000..93cdf7b4b16016b1e2ce14e60a7c074c0a978899 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Persian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103D5); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Sogdian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Sogdian.js new file mode 100644 index 0000000000000000000000000000000000000000..40587873083dc9ab4dac4a2c84f5269c397a2ee4 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Sogdian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10F00, 0x10F27); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_South_Arabian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_South_Arabian.js new file mode 100644 index 0000000000000000000000000000000000000000..0d1a33f380957ba87d41269b312579b433e3e4a0 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_South_Arabian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10A60, 0x10A7F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Turkic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Turkic.js new file mode 100644 index 0000000000000000000000000000000000000000..9d1aa35c2526e1ce130a3965334536ee2e4c76e8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Turkic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x205A, 0x2E30); +set.addRange(0x10C00, 0x10C48); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Uyghur.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Uyghur.js new file mode 100644 index 0000000000000000000000000000000000000000..06ee1b7e0052d9bbd717f6a1b271982e96cadf7e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Uyghur.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x640, 0x10AF2); +set.addRange(0x10F70, 0x10F89); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Oriya.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Oriya.js new file mode 100644 index 0000000000000000000000000000000000000000..11f09fee4636e7a8feb4ac866e5cd3151ca93f94 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Oriya.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1CDA, 0x1CF2); +set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xB01, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB3C, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4D).addRange(0xB55, 0xB57).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB63).addRange(0xB66, 0xB77); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Osage.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Osage.js new file mode 100644 index 0000000000000000000000000000000000000000..d7047ea0768c570d9b5fde634e58381339817072 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Osage.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x301, 0x304, 0x30B, 0x358); +set.addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Osmanya.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Osmanya.js new file mode 100644 index 0000000000000000000000000000000000000000..bb6ec9a73bd6b2954896cdff1063a6d9953bb819 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Osmanya.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10480, 0x1049D).addRange(0x104A0, 0x104A9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Pahawh_Hmong.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Pahawh_Hmong.js new file mode 100644 index 0000000000000000000000000000000000000000..b68ce3b294b854e054fe2c3461ed7bb69511a533 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Pahawh_Hmong.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16B00, 0x16B45).addRange(0x16B50, 0x16B59).addRange(0x16B5B, 0x16B61).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Palmyrene.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Palmyrene.js new file mode 100644 index 0000000000000000000000000000000000000000..6a4dde98bc217be4ed0d5794448bd7fa11a2e0ea --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Palmyrene.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10860, 0x1087F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Pau_Cin_Hau.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Pau_Cin_Hau.js new file mode 100644 index 0000000000000000000000000000000000000000..0cba5d2b3e827c9dd82f4351990ce86080afdb85 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Pau_Cin_Hau.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11AC0, 0x11AF8); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Phags_Pa.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Phags_Pa.js new file mode 100644 index 0000000000000000000000000000000000000000..669cba1cdf9dc3229b59132865a9d86d416e9cf9 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Phags_Pa.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1805, 0x202F, 0x3002); +set.addRange(0x1802, 0x1803).addRange(0xA840, 0xA877); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Phoenician.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Phoenician.js new file mode 100644 index 0000000000000000000000000000000000000000..9a518b9a830d9ab0802f815fa02b1fd0326846f3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Phoenician.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1091F); +set.addRange(0x10900, 0x1091B); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Psalter_Pahlavi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Psalter_Pahlavi.js new file mode 100644 index 0000000000000000000000000000000000000000..775e59951a0ffad3d1ca457f446fa0659733e917 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Psalter_Pahlavi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x640); +set.addRange(0x10B80, 0x10B91).addRange(0x10B99, 0x10B9C).addRange(0x10BA9, 0x10BAF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Rejang.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Rejang.js new file mode 100644 index 0000000000000000000000000000000000000000..cd06ee4b481db260759ca79e50fa45581cd9b37b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Rejang.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xA95F); +set.addRange(0xA930, 0xA953); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Runic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Runic.js new file mode 100644 index 0000000000000000000000000000000000000000..7f6cb9e1a30c3cd6fa2629c5ffe6c1fbbfc3aa01 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Runic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16A0, 0x16F8); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Samaritan.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Samaritan.js new file mode 100644 index 0000000000000000000000000000000000000000..32fe7d1bb88538b3822be5782d1f8db7d1d13cc6 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Samaritan.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2E31); +set.addRange(0x800, 0x82D).addRange(0x830, 0x83E); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Saurashtra.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Saurashtra.js new file mode 100644 index 0000000000000000000000000000000000000000..4b196b6475bf07c74ec78b6fb08b8749c41be850 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Saurashtra.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA880, 0xA8C5).addRange(0xA8CE, 0xA8D9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sharada.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sharada.js new file mode 100644 index 0000000000000000000000000000000000000000..1169555cd2d6c26984e5a0e69c62f7a2314cebe1 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sharada.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x951, 0x1CD7, 0x1CD9, 0x1CE0, 0x1CEA, 0x1CED, 0xA838); +set.addRange(0x1CDC, 0x1CDD).addRange(0xA830, 0xA835).addRange(0x11180, 0x111DF).addRange(0x11B60, 0x11B67); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Shavian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Shavian.js new file mode 100644 index 0000000000000000000000000000000000000000..b09a19cda9d9913d49b48319bfaa83af4675bf3d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Shavian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB7); +set.addRange(0x10450, 0x1047F); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Siddham.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Siddham.js new file mode 100644 index 0000000000000000000000000000000000000000..ae71aa7d557edd4ffd31853eab168dc4499065a8 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Siddham.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11580, 0x115B5).addRange(0x115B8, 0x115DD); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sidetic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sidetic.js new file mode 100644 index 0000000000000000000000000000000000000000..9ae69e8b199d1745dcaacc75c5e2fdf584bdb5f9 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sidetic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10940, 0x10959); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/SignWriting.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/SignWriting.js new file mode 100644 index 0000000000000000000000000000000000000000..0a20f3822af406222ccb393793fcb4e25d4951e9 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/SignWriting.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1D800, 0x1DA8B).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sinhala.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sinhala.js new file mode 100644 index 0000000000000000000000000000000000000000..7119558409aa9528ebcfed3b5f72ff7ec05f874a --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sinhala.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xDBD, 0xDCA, 0xDD6, 0x1CF2); +set.addRange(0x964, 0x965).addRange(0xD81, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDE6, 0xDEF).addRange(0xDF2, 0xDF4).addRange(0x111E1, 0x111F4); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sogdian.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sogdian.js new file mode 100644 index 0000000000000000000000000000000000000000..4a34a30397e641e626c3e1c680c1ef7f9c98e663 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sogdian.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x640); +set.addRange(0x10F30, 0x10F59); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sora_Sompeng.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sora_Sompeng.js new file mode 100644 index 0000000000000000000000000000000000000000..4bd1e2123fcf3b722f546fb57103fa463df1b54c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sora_Sompeng.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x110D0, 0x110E8).addRange(0x110F0, 0x110F9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Soyombo.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Soyombo.js new file mode 100644 index 0000000000000000000000000000000000000000..d7bb08b175412d8baed4b1f3e3f7af5af1f19c3d --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Soyombo.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11A50, 0x11AA2); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sundanese.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sundanese.js new file mode 100644 index 0000000000000000000000000000000000000000..2834227ce39d8aabc7d3e7e25c26b9b4eec25bbe --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sundanese.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1B80, 0x1BBF).addRange(0x1CC0, 0x1CC7); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sunuwar.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sunuwar.js new file mode 100644 index 0000000000000000000000000000000000000000..5c74ecbd2395090357b9f3de2df4e718fa4e59be --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Sunuwar.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x303, 0x30D, 0x310, 0x32D, 0x331); +set.addRange(0x300, 0x301).addRange(0x11BC0, 0x11BE1).addRange(0x11BF0, 0x11BF9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Syloti_Nagri.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Syloti_Nagri.js new file mode 100644 index 0000000000000000000000000000000000000000..951e1a98aace9e04533e5be6554402d98e93fc52 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Syloti_Nagri.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x964, 0x965).addRange(0x9E6, 0x9EF).addRange(0xA800, 0xA82C); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Syriac.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Syriac.js new file mode 100644 index 0000000000000000000000000000000000000000..1248bf5b99a54c9b01ea139290b1dd598967a1db --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Syriac.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x30A, 0x60C, 0x61F, 0x640, 0x670, 0x1DF8, 0x1DFA); +set.addRange(0x303, 0x304).addRange(0x307, 0x308).addRange(0x323, 0x325).addRange(0x32D, 0x32E).addRange(0x330, 0x331).addRange(0x61B, 0x61C).addRange(0x64B, 0x655).addRange(0x700, 0x70D).addRange(0x70F, 0x74A).addRange(0x74D, 0x74F).addRange(0x860, 0x86A); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tagalog.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tagalog.js new file mode 100644 index 0000000000000000000000000000000000000000..0d2bae1e580c6eaa6f56eb5c5852e02aa80dc75e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tagalog.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x171F); +set.addRange(0x1700, 0x1715).addRange(0x1735, 0x1736); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tagbanwa.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tagbanwa.js new file mode 100644 index 0000000000000000000000000000000000000000..6b74bcb2735bde2cc12d3be3a227f64dd70af503 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tagbanwa.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1735, 0x1736).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1772, 0x1773); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Le.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Le.js new file mode 100644 index 0000000000000000000000000000000000000000..c3e101699f35499bfa256b6d8d61e0d2034560e3 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Le.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x30C); +set.addRange(0x300, 0x301).addRange(0x307, 0x308).addRange(0x1040, 0x1049).addRange(0x1950, 0x196D).addRange(0x1970, 0x1974); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Tham.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Tham.js new file mode 100644 index 0000000000000000000000000000000000000000..985b631899ed98433f4d7591f01cb4235e608911 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Tham.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1A20, 0x1A5E).addRange(0x1A60, 0x1A7C).addRange(0x1A7F, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1AA0, 0x1AAD); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Viet.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Viet.js new file mode 100644 index 0000000000000000000000000000000000000000..78bf73897bfbd1f1e701299283163020b3f62190 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Viet.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xAA80, 0xAAC2).addRange(0xAADB, 0xAADF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Yo.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Yo.js new file mode 100644 index 0000000000000000000000000000000000000000..f113c0bc8b8026eddc3062f4f9d47dad6b7b2fcd --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Yo.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x1E6C0, 0x1E6DE).addRange(0x1E6E0, 0x1E6F5).addRange(0x1E6FE, 0x1E6FF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Takri.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Takri.js new file mode 100644 index 0000000000000000000000000000000000000000..496f4f17c6a9f9235e9d11611583bf08cee3129b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Takri.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x964, 0x965).addRange(0xA830, 0xA839).addRange(0x11680, 0x116B9).addRange(0x116C0, 0x116C9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tamil.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tamil.js new file mode 100644 index 0000000000000000000000000000000000000000..80e9dae4865f8ec70aa790d691af69f88ab713a2 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tamil.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0xB9C, 0xBD0, 0xBD7, 0x1CDA, 0xA8F3, 0x11301, 0x11303, 0x11FFF); +set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xB82, 0xB83).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCD).addRange(0xBE6, 0xBFA).addRange(0x1133B, 0x1133C).addRange(0x11FC0, 0x11FF1); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tangsa.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tangsa.js new file mode 100644 index 0000000000000000000000000000000000000000..423e125591a52cfccfe89f95e4ee976d4aa034f7 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tangsa.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x16A70, 0x16ABE).addRange(0x16AC0, 0x16AC9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tangut.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tangut.js new file mode 100644 index 0000000000000000000000000000000000000000..18d26fc4909f57f8738a6637187a736c6b60993b --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tangut.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x31EF, 0x16FE0); +set.addRange(0x2FF0, 0x2FFF).addRange(0x17000, 0x18AFF).addRange(0x18D00, 0x18D1E).addRange(0x18D80, 0x18DF2); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Telugu.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Telugu.js new file mode 100644 index 0000000000000000000000000000000000000000..630192360ec4e7b0cee072783e20dd9a8b34475c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Telugu.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1CD8, 0x1CDA, 0x1CF2); +set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xC00, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC3C, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC58, 0xC5A).addRange(0xC5C, 0xC5D).addRange(0xC60, 0xC63).addRange(0xC66, 0xC6F).addRange(0xC77, 0xC7F).addRange(0x1CD5, 0x1CD6); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Thaana.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Thaana.js new file mode 100644 index 0000000000000000000000000000000000000000..4bd5b3f97f7e990f02185827dda2f00fd3ed51d1 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Thaana.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x60C, 0x61F, 0xFDF2, 0xFDFD); +set.addRange(0x61B, 0x61C).addRange(0x660, 0x669).addRange(0x780, 0x7B1); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Thai.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Thai.js new file mode 100644 index 0000000000000000000000000000000000000000..681dca13dadc2d071a487585a7568239220a69d7 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Thai.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2BC, 0x2D7, 0x303, 0x331); +set.addRange(0xE01, 0xE3A).addRange(0xE40, 0xE5B); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tibetan.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tibetan.js new file mode 100644 index 0000000000000000000000000000000000000000..df2ed0f9ab7673422ca95a2f442d1a0ee27f5838 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tibetan.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xF00, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF71, 0xF97).addRange(0xF99, 0xFBC).addRange(0xFBE, 0xFCC).addRange(0xFCE, 0xFD4).addRange(0xFD9, 0xFDA).addRange(0x3008, 0x300B); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tifinagh.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tifinagh.js new file mode 100644 index 0000000000000000000000000000000000000000..9d4529007279285f054cee81ec4a3bb2b84e7ddf --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tifinagh.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x302, 0x304, 0x323, 0x2D7F); +set.addRange(0x306, 0x309).addRange(0x2D30, 0x2D67).addRange(0x2D6F, 0x2D70); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tirhuta.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tirhuta.js new file mode 100644 index 0000000000000000000000000000000000000000..318a78f392a2eb520256220de0d299b1ffbf3b24 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tirhuta.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1CD5, 0x1CE2, 0x1CF2); +set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xA830, 0xA839).addRange(0x11480, 0x114C7).addRange(0x114D0, 0x114D9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Todhri.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Todhri.js new file mode 100644 index 0000000000000000000000000000000000000000..a8ebebad6a1b1c30e4233fd7a103bb9d55ba8b5c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Todhri.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x301, 0x304, 0x307, 0x311, 0x313, 0x35E); +set.addRange(0x105C0, 0x105F3); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tolong_Siki.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tolong_Siki.js new file mode 100644 index 0000000000000000000000000000000000000000..a0bd3cee699c2f037a0e7f20015ef75d5da787e6 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tolong_Siki.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11DB0, 0x11DDB).addRange(0x11DE0, 0x11DE9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Toto.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Toto.js new file mode 100644 index 0000000000000000000000000000000000000000..67877bb8638dd3adae5d402c7c8701cfc343c12e --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Toto.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x2BC); +set.addRange(0x1E290, 0x1E2AE); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tulu_Tigalari.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tulu_Tigalari.js new file mode 100644 index 0000000000000000000000000000000000000000..97f995fd8aa4520070599f4959a878d8374d91f1 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Tulu_Tigalari.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1CF2, 0x1CF4, 0xA8F1, 0x1138B, 0x1138E, 0x113C2, 0x113C5); +set.addRange(0xCE6, 0xCEF).addRange(0xA830, 0xA835).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x113B7, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113D5).addRange(0x113D7, 0x113D8).addRange(0x113E1, 0x113E2); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ugaritic.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ugaritic.js new file mode 100644 index 0000000000000000000000000000000000000000..dd9160bee68d90edfe181ee530c9a26360a5db12 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Ugaritic.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1039F); +set.addRange(0x10380, 0x1039D); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Unknown.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Unknown.js new file mode 100644 index 0000000000000000000000000000000000000000..53a35fff971af875a93fa0e65faaf7e4b80307ae --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Unknown.js @@ -0,0 +1,12 @@ +const set = require('regenerate')(0x38B, 0x38D, 0x3A2, 0x530, 0x590, 0x70E, 0x83F, 0x85F, 0x984, 0x9A9, 0x9B1, 0x9DE, 0xA04, 0xA29, 0xA31, 0xA34, 0xA37, 0xA3D, 0xA5D, 0xA84, 0xA8E, 0xA92, 0xAA9, 0xAB1, 0xAB4, 0xAC6, 0xACA, 0xB00, 0xB04, 0xB29, 0xB31, 0xB34, 0xB5E, 0xB84, 0xB91, 0xB9B, 0xB9D, 0xBC9, 0xC0D, 0xC11, 0xC29, 0xC45, 0xC49, 0xC57, 0xC5B, 0xC8D, 0xC91, 0xCA9, 0xCB4, 0xCC5, 0xCC9, 0xCDF, 0xCF0, 0xD0D, 0xD11, 0xD45, 0xD49, 0xD80, 0xD84, 0xDB2, 0xDBC, 0xDD5, 0xDD7, 0xE83, 0xE85, 0xE8B, 0xEA4, 0xEA6, 0xEC5, 0xEC7, 0xECF, 0xF48, 0xF98, 0xFBD, 0xFCD, 0x10C6, 0x1249, 0x1257, 0x1259, 0x1289, 0x12B1, 0x12BF, 0x12C1, 0x12D7, 0x1311, 0x176D, 0x1771, 0x191F, 0x1A5F, 0x1B4D, 0x1F58, 0x1F5A, 0x1F5C, 0x1F5E, 0x1FB5, 0x1FC5, 0x1FDC, 0x1FF5, 0x1FFF, 0x2065, 0x208F, 0x2D26, 0x2DA7, 0x2DAF, 0x2DB7, 0x2DBF, 0x2DC7, 0x2DCF, 0x2DD7, 0x2DDF, 0x2E9A, 0x3040, 0x3130, 0x318F, 0x321F, 0xA9CE, 0xA9FF, 0xAB27, 0xAB2F, 0xFB37, 0xFB3D, 0xFB3F, 0xFB42, 0xFB45, 0xFE53, 0xFE67, 0xFE75, 0xFF00, 0xFFE7, 0x1000C, 0x10027, 0x1003B, 0x1003E, 0x1018F, 0x1039E, 0x1057B, 0x1058B, 0x10593, 0x10596, 0x105A2, 0x105B2, 0x105BA, 0x10786, 0x107B1, 0x10809, 0x10836, 0x10856, 0x108F3, 0x10A04, 0x10A14, 0x10A18, 0x10E7F, 0x10EAA, 0x11135, 0x111E0, 0x11212, 0x11287, 0x11289, 0x1128E, 0x1129E, 0x11304, 0x11329, 0x11331, 0x11334, 0x1133A, 0x1138A, 0x1138F, 0x113B6, 0x113C1, 0x113C6, 0x113CB, 0x113D6, 0x1145C, 0x11914, 0x11917, 0x11936, 0x11C09, 0x11C37, 0x11CA8, 0x11D07, 0x11D0A, 0x11D3B, 0x11D3E, 0x11D66, 0x11D69, 0x11D8F, 0x11D92, 0x11F11, 0x1246F, 0x16A5F, 0x16ABF, 0x16B5A, 0x16B62, 0x1AFF4, 0x1AFFC, 0x1AFFF, 0x1D455, 0x1D49D, 0x1D4AD, 0x1D4BA, 0x1D4BC, 0x1D4C4, 0x1D506, 0x1D515, 0x1D51D, 0x1D53A, 0x1D53F, 0x1D545, 0x1D551, 0x1DAA0, 0x1E007, 0x1E022, 0x1E025, 0x1E6DF, 0x1E7E7, 0x1E7EC, 0x1E7EF, 0x1E7FF, 0x1EE04, 0x1EE20, 0x1EE23, 0x1EE28, 0x1EE33, 0x1EE38, 0x1EE3A, 0x1EE48, 0x1EE4A, 0x1EE4C, 0x1EE50, 0x1EE53, 0x1EE58, 0x1EE5A, 0x1EE5C, 0x1EE5E, 0x1EE60, 0x1EE63, 0x1EE6B, 0x1EE73, 0x1EE78, 0x1EE7D, 0x1EE7F, 0x1EE8A, 0x1EEA4, 0x1EEAA, 0x1F0C0, 0x1F0D0, 0x1FAC7, 0x1FB93); +set.addRange(0x378, 0x379).addRange(0x380, 0x383).addRange(0x557, 0x558).addRange(0x58B, 0x58C).addRange(0x5C8, 0x5CF).addRange(0x5EB, 0x5EE).addRange(0x5F5, 0x5FF).addRange(0x74B, 0x74C).addRange(0x7B2, 0x7BF).addRange(0x7FB, 0x7FC).addRange(0x82E, 0x82F).addRange(0x85C, 0x85D).addRange(0x86B, 0x86F).addRange(0x892, 0x896).addRange(0x98D, 0x98E).addRange(0x991, 0x992).addRange(0x9B3, 0x9B5).addRange(0x9BA, 0x9BB).addRange(0x9C5, 0x9C6).addRange(0x9C9, 0x9CA).addRange(0x9CF, 0x9D6).addRange(0x9D8, 0x9DB).addRange(0x9E4, 0x9E5).addRange(0x9FF, 0xA00).addRange(0xA0B, 0xA0E).addRange(0xA11, 0xA12).addRange(0xA3A, 0xA3B).addRange(0xA43, 0xA46).addRange(0xA49, 0xA4A).addRange(0xA4E, 0xA50).addRange(0xA52, 0xA58).addRange(0xA5F, 0xA65).addRange(0xA77, 0xA80).addRange(0xABA, 0xABB).addRange(0xACE, 0xACF).addRange(0xAD1, 0xADF).addRange(0xAE4, 0xAE5).addRange(0xAF2, 0xAF8).addRange(0xB0D, 0xB0E).addRange(0xB11, 0xB12).addRange(0xB3A, 0xB3B).addRange(0xB45, 0xB46).addRange(0xB49, 0xB4A).addRange(0xB4E, 0xB54).addRange(0xB58, 0xB5B).addRange(0xB64, 0xB65).addRange(0xB78, 0xB81).addRange(0xB8B, 0xB8D).addRange(0xB96, 0xB98).addRange(0xBA0, 0xBA2).addRange(0xBA5, 0xBA7); +set.addRange(0xBAB, 0xBAD).addRange(0xBBA, 0xBBD).addRange(0xBC3, 0xBC5).addRange(0xBCE, 0xBCF).addRange(0xBD1, 0xBD6).addRange(0xBD8, 0xBE5).addRange(0xBFB, 0xBFF).addRange(0xC3A, 0xC3B).addRange(0xC4E, 0xC54).addRange(0xC5E, 0xC5F).addRange(0xC64, 0xC65).addRange(0xC70, 0xC76).addRange(0xCBA, 0xCBB).addRange(0xCCE, 0xCD4).addRange(0xCD7, 0xCDB).addRange(0xCE4, 0xCE5).addRange(0xCF4, 0xCFF).addRange(0xD50, 0xD53).addRange(0xD64, 0xD65).addRange(0xD97, 0xD99).addRange(0xDBE, 0xDBF).addRange(0xDC7, 0xDC9).addRange(0xDCB, 0xDCE).addRange(0xDE0, 0xDE5).addRange(0xDF0, 0xDF1).addRange(0xDF5, 0xE00).addRange(0xE3B, 0xE3E).addRange(0xE5C, 0xE80).addRange(0xEBE, 0xEBF).addRange(0xEDA, 0xEDB).addRange(0xEE0, 0xEFF).addRange(0xF6D, 0xF70).addRange(0xFDB, 0xFFF).addRange(0x10C8, 0x10CC).addRange(0x10CE, 0x10CF).addRange(0x124E, 0x124F).addRange(0x125E, 0x125F).addRange(0x128E, 0x128F).addRange(0x12B6, 0x12B7).addRange(0x12C6, 0x12C7).addRange(0x1316, 0x1317).addRange(0x135B, 0x135C).addRange(0x137D, 0x137F).addRange(0x139A, 0x139F).addRange(0x13F6, 0x13F7).addRange(0x13FE, 0x13FF).addRange(0x169D, 0x169F).addRange(0x16F9, 0x16FF).addRange(0x1716, 0x171E).addRange(0x1737, 0x173F).addRange(0x1754, 0x175F); +set.addRange(0x1774, 0x177F).addRange(0x17DE, 0x17DF).addRange(0x17EA, 0x17EF).addRange(0x17FA, 0x17FF).addRange(0x181A, 0x181F).addRange(0x1879, 0x187F).addRange(0x18AB, 0x18AF).addRange(0x18F6, 0x18FF).addRange(0x192C, 0x192F).addRange(0x193C, 0x193F).addRange(0x1941, 0x1943).addRange(0x196E, 0x196F).addRange(0x1975, 0x197F).addRange(0x19AC, 0x19AF).addRange(0x19CA, 0x19CF).addRange(0x19DB, 0x19DD).addRange(0x1A1C, 0x1A1D).addRange(0x1A7D, 0x1A7E).addRange(0x1A8A, 0x1A8F).addRange(0x1A9A, 0x1A9F).addRange(0x1AAE, 0x1AAF).addRange(0x1ADE, 0x1ADF).addRange(0x1AEC, 0x1AFF).addRange(0x1BF4, 0x1BFB).addRange(0x1C38, 0x1C3A).addRange(0x1C4A, 0x1C4C).addRange(0x1C8B, 0x1C8F).addRange(0x1CBB, 0x1CBC).addRange(0x1CC8, 0x1CCF).addRange(0x1CFB, 0x1CFF).addRange(0x1F16, 0x1F17).addRange(0x1F1E, 0x1F1F).addRange(0x1F46, 0x1F47).addRange(0x1F4E, 0x1F4F).addRange(0x1F7E, 0x1F7F).addRange(0x1FD4, 0x1FD5).addRange(0x1FF0, 0x1FF1).addRange(0x2072, 0x2073).addRange(0x209D, 0x209F).addRange(0x20C2, 0x20CF).addRange(0x20F1, 0x20FF).addRange(0x218C, 0x218F).addRange(0x242A, 0x243F).addRange(0x244B, 0x245F).addRange(0x2B74, 0x2B75).addRange(0x2CF4, 0x2CF8).addRange(0x2D28, 0x2D2C).addRange(0x2D2E, 0x2D2F).addRange(0x2D68, 0x2D6E).addRange(0x2D71, 0x2D7E).addRange(0x2D97, 0x2D9F); +set.addRange(0x2E5E, 0x2E7F).addRange(0x2EF4, 0x2EFF).addRange(0x2FD6, 0x2FEF).addRange(0x3097, 0x3098).addRange(0x3100, 0x3104).addRange(0x31E6, 0x31EE).addRange(0xA48D, 0xA48F).addRange(0xA4C7, 0xA4CF).addRange(0xA62C, 0xA63F).addRange(0xA6F8, 0xA6FF).addRange(0xA7DD, 0xA7F0).addRange(0xA82D, 0xA82F).addRange(0xA83A, 0xA83F).addRange(0xA878, 0xA87F).addRange(0xA8C6, 0xA8CD).addRange(0xA8DA, 0xA8DF).addRange(0xA954, 0xA95E).addRange(0xA97D, 0xA97F).addRange(0xA9DA, 0xA9DD).addRange(0xAA37, 0xAA3F).addRange(0xAA4E, 0xAA4F).addRange(0xAA5A, 0xAA5B).addRange(0xAAC3, 0xAADA).addRange(0xAAF7, 0xAB00).addRange(0xAB07, 0xAB08).addRange(0xAB0F, 0xAB10).addRange(0xAB17, 0xAB1F).addRange(0xAB6C, 0xAB6F).addRange(0xABEE, 0xABEF).addRange(0xABFA, 0xABFF).addRange(0xD7A4, 0xD7AF).addRange(0xD7C7, 0xD7CA).addRange(0xD7FC, 0xF8FF).addRange(0xFA6E, 0xFA6F).addRange(0xFADA, 0xFAFF).addRange(0xFB07, 0xFB12).addRange(0xFB18, 0xFB1C).addRange(0xFDD0, 0xFDEF).addRange(0xFE1A, 0xFE1F).addRange(0xFE6C, 0xFE6F).addRange(0xFEFD, 0xFEFE).addRange(0xFFBF, 0xFFC1).addRange(0xFFC8, 0xFFC9).addRange(0xFFD0, 0xFFD1).addRange(0xFFD8, 0xFFD9).addRange(0xFFDD, 0xFFDF).addRange(0xFFEF, 0xFFF8).addRange(0xFFFE, 0xFFFF).addRange(0x1004E, 0x1004F).addRange(0x1005E, 0x1007F).addRange(0x100FB, 0x100FF); +set.addRange(0x10103, 0x10106).addRange(0x10134, 0x10136).addRange(0x1019D, 0x1019F).addRange(0x101A1, 0x101CF).addRange(0x101FE, 0x1027F).addRange(0x1029D, 0x1029F).addRange(0x102D1, 0x102DF).addRange(0x102FC, 0x102FF).addRange(0x10324, 0x1032C).addRange(0x1034B, 0x1034F).addRange(0x1037B, 0x1037F).addRange(0x103C4, 0x103C7).addRange(0x103D6, 0x103FF).addRange(0x1049E, 0x1049F).addRange(0x104AA, 0x104AF).addRange(0x104D4, 0x104D7).addRange(0x104FC, 0x104FF).addRange(0x10528, 0x1052F).addRange(0x10564, 0x1056E).addRange(0x105BD, 0x105BF).addRange(0x105F4, 0x105FF).addRange(0x10737, 0x1073F).addRange(0x10756, 0x1075F).addRange(0x10768, 0x1077F).addRange(0x107BB, 0x107FF).addRange(0x10806, 0x10807).addRange(0x10839, 0x1083B).addRange(0x1083D, 0x1083E).addRange(0x1089F, 0x108A6).addRange(0x108B0, 0x108DF).addRange(0x108F6, 0x108FA).addRange(0x1091C, 0x1091E).addRange(0x1093A, 0x1093E).addRange(0x1095A, 0x1097F).addRange(0x109B8, 0x109BB).addRange(0x109D0, 0x109D1).addRange(0x10A07, 0x10A0B).addRange(0x10A36, 0x10A37).addRange(0x10A3B, 0x10A3E).addRange(0x10A49, 0x10A4F).addRange(0x10A59, 0x10A5F).addRange(0x10AA0, 0x10ABF).addRange(0x10AE7, 0x10AEA).addRange(0x10AF7, 0x10AFF).addRange(0x10B36, 0x10B38).addRange(0x10B56, 0x10B57).addRange(0x10B73, 0x10B77).addRange(0x10B92, 0x10B98).addRange(0x10B9D, 0x10BA8).addRange(0x10BB0, 0x10BFF).addRange(0x10C49, 0x10C7F); +set.addRange(0x10CB3, 0x10CBF).addRange(0x10CF3, 0x10CF9).addRange(0x10D28, 0x10D2F).addRange(0x10D3A, 0x10D3F).addRange(0x10D66, 0x10D68).addRange(0x10D86, 0x10D8D).addRange(0x10D90, 0x10E5F).addRange(0x10EAE, 0x10EAF).addRange(0x10EB2, 0x10EC1).addRange(0x10EC8, 0x10ECF).addRange(0x10ED9, 0x10EF9).addRange(0x10F28, 0x10F2F).addRange(0x10F5A, 0x10F6F).addRange(0x10F8A, 0x10FAF).addRange(0x10FCC, 0x10FDF).addRange(0x10FF7, 0x10FFF).addRange(0x1104E, 0x11051).addRange(0x11076, 0x1107E).addRange(0x110C3, 0x110CC).addRange(0x110CE, 0x110CF).addRange(0x110E9, 0x110EF).addRange(0x110FA, 0x110FF).addRange(0x11148, 0x1114F).addRange(0x11177, 0x1117F).addRange(0x111F5, 0x111FF).addRange(0x11242, 0x1127F).addRange(0x112AA, 0x112AF).addRange(0x112EB, 0x112EF).addRange(0x112FA, 0x112FF).addRange(0x1130D, 0x1130E).addRange(0x11311, 0x11312).addRange(0x11345, 0x11346).addRange(0x11349, 0x1134A).addRange(0x1134E, 0x1134F).addRange(0x11351, 0x11356).addRange(0x11358, 0x1135C).addRange(0x11364, 0x11365).addRange(0x1136D, 0x1136F).addRange(0x11375, 0x1137F).addRange(0x1138C, 0x1138D).addRange(0x113C3, 0x113C4).addRange(0x113D9, 0x113E0).addRange(0x113E3, 0x113FF).addRange(0x11462, 0x1147F).addRange(0x114C8, 0x114CF).addRange(0x114DA, 0x1157F).addRange(0x115B6, 0x115B7).addRange(0x115DE, 0x115FF).addRange(0x11645, 0x1164F).addRange(0x1165A, 0x1165F).addRange(0x1166D, 0x1167F); +set.addRange(0x116BA, 0x116BF).addRange(0x116CA, 0x116CF).addRange(0x116E4, 0x116FF).addRange(0x1171B, 0x1171C).addRange(0x1172C, 0x1172F).addRange(0x11747, 0x117FF).addRange(0x1183C, 0x1189F).addRange(0x118F3, 0x118FE).addRange(0x11907, 0x11908).addRange(0x1190A, 0x1190B).addRange(0x11939, 0x1193A).addRange(0x11947, 0x1194F).addRange(0x1195A, 0x1199F).addRange(0x119A8, 0x119A9).addRange(0x119D8, 0x119D9).addRange(0x119E5, 0x119FF).addRange(0x11A48, 0x11A4F).addRange(0x11AA3, 0x11AAF).addRange(0x11AF9, 0x11AFF).addRange(0x11B0A, 0x11B5F).addRange(0x11B68, 0x11BBF).addRange(0x11BE2, 0x11BEF).addRange(0x11BFA, 0x11BFF).addRange(0x11C46, 0x11C4F).addRange(0x11C6D, 0x11C6F).addRange(0x11C90, 0x11C91).addRange(0x11CB7, 0x11CFF).addRange(0x11D37, 0x11D39).addRange(0x11D48, 0x11D4F).addRange(0x11D5A, 0x11D5F).addRange(0x11D99, 0x11D9F).addRange(0x11DAA, 0x11DAF).addRange(0x11DDC, 0x11DDF).addRange(0x11DEA, 0x11EDF).addRange(0x11EF9, 0x11EFF).addRange(0x11F3B, 0x11F3D).addRange(0x11F5B, 0x11FAF).addRange(0x11FB1, 0x11FBF).addRange(0x11FF2, 0x11FFE).addRange(0x1239A, 0x123FF).addRange(0x12475, 0x1247F).addRange(0x12544, 0x12F8F).addRange(0x12FF3, 0x12FFF).addRange(0x13456, 0x1345F).addRange(0x143FB, 0x143FF).addRange(0x14647, 0x160FF).addRange(0x1613A, 0x167FF).addRange(0x16A39, 0x16A3F).addRange(0x16A6A, 0x16A6D).addRange(0x16ACA, 0x16ACF).addRange(0x16AEE, 0x16AEF); +set.addRange(0x16AF6, 0x16AFF).addRange(0x16B46, 0x16B4F).addRange(0x16B78, 0x16B7C).addRange(0x16B90, 0x16D3F).addRange(0x16D7A, 0x16E3F).addRange(0x16E9B, 0x16E9F).addRange(0x16EB9, 0x16EBA).addRange(0x16ED4, 0x16EFF).addRange(0x16F4B, 0x16F4E).addRange(0x16F88, 0x16F8E).addRange(0x16FA0, 0x16FDF).addRange(0x16FE5, 0x16FEF).addRange(0x16FF7, 0x16FFF).addRange(0x18CD6, 0x18CFE).addRange(0x18D1F, 0x18D7F).addRange(0x18DF3, 0x1AFEF).addRange(0x1B123, 0x1B131).addRange(0x1B133, 0x1B14F).addRange(0x1B153, 0x1B154).addRange(0x1B156, 0x1B163).addRange(0x1B168, 0x1B16F).addRange(0x1B2FC, 0x1BBFF).addRange(0x1BC6B, 0x1BC6F).addRange(0x1BC7D, 0x1BC7F).addRange(0x1BC89, 0x1BC8F).addRange(0x1BC9A, 0x1BC9B).addRange(0x1BCA4, 0x1CBFF).addRange(0x1CCFD, 0x1CCFF).addRange(0x1CEB4, 0x1CEB9).addRange(0x1CED1, 0x1CEDF).addRange(0x1CEF1, 0x1CEFF).addRange(0x1CF2E, 0x1CF2F).addRange(0x1CF47, 0x1CF4F).addRange(0x1CFC4, 0x1CFFF).addRange(0x1D0F6, 0x1D0FF).addRange(0x1D127, 0x1D128).addRange(0x1D1EB, 0x1D1FF).addRange(0x1D246, 0x1D2BF).addRange(0x1D2D4, 0x1D2DF).addRange(0x1D2F4, 0x1D2FF).addRange(0x1D357, 0x1D35F).addRange(0x1D379, 0x1D3FF).addRange(0x1D4A0, 0x1D4A1).addRange(0x1D4A3, 0x1D4A4).addRange(0x1D4A7, 0x1D4A8).addRange(0x1D50B, 0x1D50C).addRange(0x1D547, 0x1D549).addRange(0x1D6A6, 0x1D6A7).addRange(0x1D7CC, 0x1D7CD).addRange(0x1DA8C, 0x1DA9A).addRange(0x1DAB0, 0x1DEFF); +set.addRange(0x1DF1F, 0x1DF24).addRange(0x1DF2B, 0x1DFFF).addRange(0x1E019, 0x1E01A).addRange(0x1E02B, 0x1E02F).addRange(0x1E06E, 0x1E08E).addRange(0x1E090, 0x1E0FF).addRange(0x1E12D, 0x1E12F).addRange(0x1E13E, 0x1E13F).addRange(0x1E14A, 0x1E14D).addRange(0x1E150, 0x1E28F).addRange(0x1E2AF, 0x1E2BF).addRange(0x1E2FA, 0x1E2FE).addRange(0x1E300, 0x1E4CF).addRange(0x1E4FA, 0x1E5CF).addRange(0x1E5FB, 0x1E5FE).addRange(0x1E600, 0x1E6BF).addRange(0x1E6F6, 0x1E6FD).addRange(0x1E700, 0x1E7DF).addRange(0x1E8C5, 0x1E8C6).addRange(0x1E8D7, 0x1E8FF).addRange(0x1E94C, 0x1E94F).addRange(0x1E95A, 0x1E95D).addRange(0x1E960, 0x1EC70).addRange(0x1ECB5, 0x1ED00).addRange(0x1ED3E, 0x1EDFF).addRange(0x1EE25, 0x1EE26).addRange(0x1EE3C, 0x1EE41).addRange(0x1EE43, 0x1EE46).addRange(0x1EE55, 0x1EE56).addRange(0x1EE65, 0x1EE66).addRange(0x1EE9C, 0x1EEA0).addRange(0x1EEBC, 0x1EEEF).addRange(0x1EEF2, 0x1EFFF).addRange(0x1F02C, 0x1F02F).addRange(0x1F094, 0x1F09F).addRange(0x1F0AF, 0x1F0B0).addRange(0x1F0F6, 0x1F0FF).addRange(0x1F1AE, 0x1F1E5).addRange(0x1F203, 0x1F20F).addRange(0x1F23C, 0x1F23F).addRange(0x1F249, 0x1F24F).addRange(0x1F252, 0x1F25F).addRange(0x1F266, 0x1F2FF).addRange(0x1F6D9, 0x1F6DB).addRange(0x1F6ED, 0x1F6EF).addRange(0x1F6FD, 0x1F6FF).addRange(0x1F7DA, 0x1F7DF).addRange(0x1F7EC, 0x1F7EF).addRange(0x1F7F1, 0x1F7FF).addRange(0x1F80C, 0x1F80F).addRange(0x1F848, 0x1F84F); +set.addRange(0x1F85A, 0x1F85F).addRange(0x1F888, 0x1F88F).addRange(0x1F8AE, 0x1F8AF).addRange(0x1F8BC, 0x1F8BF).addRange(0x1F8C2, 0x1F8CF).addRange(0x1F8D9, 0x1F8FF).addRange(0x1FA58, 0x1FA5F).addRange(0x1FA6E, 0x1FA6F).addRange(0x1FA7D, 0x1FA7F).addRange(0x1FA8B, 0x1FA8D).addRange(0x1FAC9, 0x1FACC).addRange(0x1FADD, 0x1FADE).addRange(0x1FAEB, 0x1FAEE).addRange(0x1FAF9, 0x1FAFF).addRange(0x1FBFB, 0x1FFFF).addRange(0x2A6E0, 0x2A6FF).addRange(0x2B81E, 0x2B81F).addRange(0x2CEAE, 0x2CEAF).addRange(0x2EBE1, 0x2EBEF).addRange(0x2EE5E, 0x2F7FF).addRange(0x2FA1E, 0x2FFFF).addRange(0x3134B, 0x3134F).addRange(0x3347A, 0xE0000).addRange(0xE0002, 0xE001F).addRange(0xE0080, 0xE00FF).addRange(0xE01F0, 0x10FFFF); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Vai.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Vai.js new file mode 100644 index 0000000000000000000000000000000000000000..e06faa6a4964df65869718f18f2df0406d1d6790 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Vai.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0xA500, 0xA62B); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Vithkuqi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Vithkuqi.js new file mode 100644 index 0000000000000000000000000000000000000000..eadb23490d25f428e66f327023616f5b24c435e4 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Vithkuqi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Wancho.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Wancho.js new file mode 100644 index 0000000000000000000000000000000000000000..777b2b7091f71c5c58c707c92afaf0f57792c32c --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Wancho.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x1E2FF); +set.addRange(0x1E2C0, 0x1E2F9); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Warang_Citi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Warang_Citi.js new file mode 100644 index 0000000000000000000000000000000000000000..8c98bbc26ca3d1a2f0d129ade0cd03649b6de205 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Warang_Citi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x118FF); +set.addRange(0x118A0, 0x118F2); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Yezidi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Yezidi.js new file mode 100644 index 0000000000000000000000000000000000000000..057a66d5857e2b0d3bda6b799e6d9672459fa0bc --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Yezidi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x60C, 0x61B, 0x61F); +set.addRange(0x660, 0x669).addRange(0x10E80, 0x10EA9).addRange(0x10EAB, 0x10EAD).addRange(0x10EB0, 0x10EB1); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Yi.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Yi.js new file mode 100644 index 0000000000000000000000000000000000000000..6ba21e9f37d886ea7086e0966c2cd9e4c975f9db --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Yi.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(0x30FB); +set.addRange(0x3001, 0x3002).addRange(0x3008, 0x3011).addRange(0x3014, 0x301B).addRange(0xA000, 0xA48C).addRange(0xA490, 0xA4C6).addRange(0xFF61, 0xFF65); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Zanabazar_Square.js b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Zanabazar_Square.js new file mode 100644 index 0000000000000000000000000000000000000000..0f4afc629ae7c663b0867e5c2f2f0652e5e84b42 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/Script_Extensions/Zanabazar_Square.js @@ -0,0 +1,3 @@ +const set = require('regenerate')(); +set.addRange(0x11A00, 0x11A47); +exports.characters = set; diff --git a/tools/ui/node_modules/regenerate-unicode-properties/index.js b/tools/ui/node_modules/regenerate-unicode-properties/index.js new file mode 100644 index 0000000000000000000000000000000000000000..81c629c7d28c471ec0a81e51c8adda333169bdef --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/index.js @@ -0,0 +1,460 @@ +module.exports = new Map([ + ['General_Category', [ + 'Cased_Letter', + 'Close_Punctuation', + 'Connector_Punctuation', + 'Control', + 'Currency_Symbol', + 'Dash_Punctuation', + 'Decimal_Number', + 'Enclosing_Mark', + 'Final_Punctuation', + 'Format', + 'Initial_Punctuation', + 'Letter', + 'Letter_Number', + 'Line_Separator', + 'Lowercase_Letter', + 'Mark', + 'Math_Symbol', + 'Modifier_Letter', + 'Modifier_Symbol', + 'Nonspacing_Mark', + 'Number', + 'Open_Punctuation', + 'Other', + 'Other_Letter', + 'Other_Number', + 'Other_Punctuation', + 'Other_Symbol', + 'Paragraph_Separator', + 'Private_Use', + 'Punctuation', + 'Separator', + 'Space_Separator', + 'Spacing_Mark', + 'Surrogate', + 'Symbol', + 'Titlecase_Letter', + 'Unassigned', + 'Uppercase_Letter' + ]], + ['Script', [ + 'Adlam', + 'Ahom', + 'Anatolian_Hieroglyphs', + 'Arabic', + 'Armenian', + 'Avestan', + 'Balinese', + 'Bamum', + 'Bassa_Vah', + 'Batak', + 'Bengali', + 'Beria_Erfe', + 'Bhaiksuki', + 'Bopomofo', + 'Brahmi', + 'Braille', + 'Buginese', + 'Buhid', + 'Canadian_Aboriginal', + 'Carian', + 'Caucasian_Albanian', + 'Chakma', + 'Cham', + 'Cherokee', + 'Chorasmian', + 'Common', + 'Coptic', + 'Cuneiform', + 'Cypriot', + 'Cypro_Minoan', + 'Cyrillic', + 'Deseret', + 'Devanagari', + 'Dives_Akuru', + 'Dogra', + 'Duployan', + 'Egyptian_Hieroglyphs', + 'Elbasan', + 'Elymaic', + 'Ethiopic', + 'Garay', + 'Georgian', + 'Glagolitic', + 'Gothic', + 'Grantha', + 'Greek', + 'Gujarati', + 'Gunjala_Gondi', + 'Gurmukhi', + 'Gurung_Khema', + 'Han', + 'Hangul', + 'Hanifi_Rohingya', + 'Hanunoo', + 'Hatran', + 'Hebrew', + 'Hiragana', + 'Imperial_Aramaic', + 'Inherited', + 'Inscriptional_Pahlavi', + 'Inscriptional_Parthian', + 'Javanese', + 'Kaithi', + 'Kannada', + 'Katakana', + 'Kawi', + 'Kayah_Li', + 'Kharoshthi', + 'Khitan_Small_Script', + 'Khmer', + 'Khojki', + 'Khudawadi', + 'Kirat_Rai', + 'Lao', + 'Latin', + 'Lepcha', + 'Limbu', + 'Linear_A', + 'Linear_B', + 'Lisu', + 'Lycian', + 'Lydian', + 'Mahajani', + 'Makasar', + 'Malayalam', + 'Mandaic', + 'Manichaean', + 'Marchen', + 'Masaram_Gondi', + 'Medefaidrin', + 'Meetei_Mayek', + 'Mende_Kikakui', + 'Meroitic_Cursive', + 'Meroitic_Hieroglyphs', + 'Miao', + 'Modi', + 'Mongolian', + 'Mro', + 'Multani', + 'Myanmar', + 'Nabataean', + 'Nag_Mundari', + 'Nandinagari', + 'New_Tai_Lue', + 'Newa', + 'Nko', + 'Nushu', + 'Nyiakeng_Puachue_Hmong', + 'Ogham', + 'Ol_Chiki', + 'Ol_Onal', + 'Old_Hungarian', + 'Old_Italic', + 'Old_North_Arabian', + 'Old_Permic', + 'Old_Persian', + 'Old_Sogdian', + 'Old_South_Arabian', + 'Old_Turkic', + 'Old_Uyghur', + 'Oriya', + 'Osage', + 'Osmanya', + 'Pahawh_Hmong', + 'Palmyrene', + 'Pau_Cin_Hau', + 'Phags_Pa', + 'Phoenician', + 'Psalter_Pahlavi', + 'Rejang', + 'Runic', + 'Samaritan', + 'Saurashtra', + 'Sharada', + 'Shavian', + 'Siddham', + 'Sidetic', + 'SignWriting', + 'Sinhala', + 'Sogdian', + 'Sora_Sompeng', + 'Soyombo', + 'Sundanese', + 'Sunuwar', + 'Syloti_Nagri', + 'Syriac', + 'Tagalog', + 'Tagbanwa', + 'Tai_Le', + 'Tai_Tham', + 'Tai_Viet', + 'Tai_Yo', + 'Takri', + 'Tamil', + 'Tangsa', + 'Tangut', + 'Telugu', + 'Thaana', + 'Thai', + 'Tibetan', + 'Tifinagh', + 'Tirhuta', + 'Todhri', + 'Tolong_Siki', + 'Toto', + 'Tulu_Tigalari', + 'Ugaritic', + 'Unknown', + 'Vai', + 'Vithkuqi', + 'Wancho', + 'Warang_Citi', + 'Yezidi', + 'Yi', + 'Zanabazar_Square' + ]], + ['Script_Extensions', [ + 'Adlam', + 'Ahom', + 'Anatolian_Hieroglyphs', + 'Arabic', + 'Armenian', + 'Avestan', + 'Balinese', + 'Bamum', + 'Bassa_Vah', + 'Batak', + 'Bengali', + 'Beria_Erfe', + 'Bhaiksuki', + 'Bopomofo', + 'Brahmi', + 'Braille', + 'Buginese', + 'Buhid', + 'Canadian_Aboriginal', + 'Carian', + 'Caucasian_Albanian', + 'Chakma', + 'Cham', + 'Cherokee', + 'Chorasmian', + 'Common', + 'Coptic', + 'Cuneiform', + 'Cypriot', + 'Cypro_Minoan', + 'Cyrillic', + 'Deseret', + 'Devanagari', + 'Dives_Akuru', + 'Dogra', + 'Duployan', + 'Egyptian_Hieroglyphs', + 'Elbasan', + 'Elymaic', + 'Ethiopic', + 'Garay', + 'Georgian', + 'Glagolitic', + 'Gothic', + 'Grantha', + 'Greek', + 'Gujarati', + 'Gunjala_Gondi', + 'Gurmukhi', + 'Gurung_Khema', + 'Han', + 'Hangul', + 'Hanifi_Rohingya', + 'Hanunoo', + 'Hatran', + 'Hebrew', + 'Hiragana', + 'Imperial_Aramaic', + 'Inherited', + 'Inscriptional_Pahlavi', + 'Inscriptional_Parthian', + 'Javanese', + 'Kaithi', + 'Kannada', + 'Katakana', + 'Kawi', + 'Kayah_Li', + 'Kharoshthi', + 'Khitan_Small_Script', + 'Khmer', + 'Khojki', + 'Khudawadi', + 'Kirat_Rai', + 'Lao', + 'Latin', + 'Lepcha', + 'Limbu', + 'Linear_A', + 'Linear_B', + 'Lisu', + 'Lycian', + 'Lydian', + 'Mahajani', + 'Makasar', + 'Malayalam', + 'Mandaic', + 'Manichaean', + 'Marchen', + 'Masaram_Gondi', + 'Medefaidrin', + 'Meetei_Mayek', + 'Mende_Kikakui', + 'Meroitic_Cursive', + 'Meroitic_Hieroglyphs', + 'Miao', + 'Modi', + 'Mongolian', + 'Mro', + 'Multani', + 'Myanmar', + 'Nabataean', + 'Nag_Mundari', + 'Nandinagari', + 'New_Tai_Lue', + 'Newa', + 'Nko', + 'Nushu', + 'Nyiakeng_Puachue_Hmong', + 'Ogham', + 'Ol_Chiki', + 'Ol_Onal', + 'Old_Hungarian', + 'Old_Italic', + 'Old_North_Arabian', + 'Old_Permic', + 'Old_Persian', + 'Old_Sogdian', + 'Old_South_Arabian', + 'Old_Turkic', + 'Old_Uyghur', + 'Oriya', + 'Osage', + 'Osmanya', + 'Pahawh_Hmong', + 'Palmyrene', + 'Pau_Cin_Hau', + 'Phags_Pa', + 'Phoenician', + 'Psalter_Pahlavi', + 'Rejang', + 'Runic', + 'Samaritan', + 'Saurashtra', + 'Sharada', + 'Shavian', + 'Siddham', + 'Sidetic', + 'SignWriting', + 'Sinhala', + 'Sogdian', + 'Sora_Sompeng', + 'Soyombo', + 'Sundanese', + 'Sunuwar', + 'Syloti_Nagri', + 'Syriac', + 'Tagalog', + 'Tagbanwa', + 'Tai_Le', + 'Tai_Tham', + 'Tai_Viet', + 'Tai_Yo', + 'Takri', + 'Tamil', + 'Tangsa', + 'Tangut', + 'Telugu', + 'Thaana', + 'Thai', + 'Tibetan', + 'Tifinagh', + 'Tirhuta', + 'Todhri', + 'Tolong_Siki', + 'Toto', + 'Tulu_Tigalari', + 'Ugaritic', + 'Unknown', + 'Vai', + 'Vithkuqi', + 'Wancho', + 'Warang_Citi', + 'Yezidi', + 'Yi', + 'Zanabazar_Square' + ]], + ['Binary_Property', [ + 'ASCII', + 'ASCII_Hex_Digit', + 'Alphabetic', + 'Any', + 'Assigned', + 'Bidi_Control', + 'Bidi_Mirrored', + 'Case_Ignorable', + 'Cased', + 'Changes_When_Casefolded', + 'Changes_When_Casemapped', + 'Changes_When_Lowercased', + 'Changes_When_NFKC_Casefolded', + 'Changes_When_Titlecased', + 'Changes_When_Uppercased', + 'Dash', + 'Default_Ignorable_Code_Point', + 'Deprecated', + 'Diacritic', + 'Emoji', + 'Emoji_Component', + 'Emoji_Modifier', + 'Emoji_Modifier_Base', + 'Emoji_Presentation', + 'Extended_Pictographic', + 'Extender', + 'Grapheme_Base', + 'Grapheme_Extend', + 'Hex_Digit', + 'IDS_Binary_Operator', + 'IDS_Trinary_Operator', + 'ID_Continue', + 'ID_Start', + 'Ideographic', + 'Join_Control', + 'Logical_Order_Exception', + 'Lowercase', + 'Math', + 'Noncharacter_Code_Point', + 'Pattern_Syntax', + 'Pattern_White_Space', + 'Quotation_Mark', + 'Radical', + 'Regional_Indicator', + 'Sentence_Terminal', + 'Soft_Dotted', + 'Terminal_Punctuation', + 'Unified_Ideograph', + 'Uppercase', + 'Variation_Selector', + 'White_Space', + 'XID_Continue', + 'XID_Start' + ]], + ['Property_of_Strings', [ + 'Basic_Emoji', + 'Emoji_Keycap_Sequence', + 'RGI_Emoji', + 'RGI_Emoji_Flag_Sequence', + 'RGI_Emoji_Modifier_Sequence', + 'RGI_Emoji_Tag_Sequence', + 'RGI_Emoji_ZWJ_Sequence' + ]] +]); diff --git a/tools/ui/node_modules/regenerate-unicode-properties/package.json b/tools/ui/node_modules/regenerate-unicode-properties/package.json new file mode 100644 index 0000000000000000000000000000000000000000..c78cb29d387fd08db0fca08f6c89e3c3453e9b30 --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/package.json @@ -0,0 +1,47 @@ +{ + "name": "regenerate-unicode-properties", + "version": "10.2.2", + "description": "Regenerate sets for Unicode properties and values.", + "homepage": "https://github.com/mathiasbynens/regenerate-unicode-properties", + "main": "index.js", + "engines": { + "node": ">=4" + }, + "files": [ + "LICENSE-MIT.txt", + "index.js", + "unicode-version.js", + "Binary_Property", + "General_Category", + "Property_of_Strings", + "Script", + "Script_Extensions" + ], + "keywords": [ + "unicode", + "unicode-data", + "regenerate" + ], + "license": "MIT", + "author": { + "name": "Mathias Bynens", + "url": "https://mathiasbynens.be/" + }, + "repository": { + "type": "git", + "url": "https://github.com/mathiasbynens/regenerate-unicode-properties.git" + }, + "bugs": "https://github.com/mathiasbynens/regenerate-unicode-properties/issues", + "dependencies": { + "regenerate": "^1.4.2" + }, + "devDependencies": { + "@unicode/unicode-17.0.0": "^1.6.12", + "jsesc": "^3.1.0", + "unicode-canonical-property-names-ecmascript": "^2.0.1" + }, + "scripts": { + "build": "node build.js", + "test": "node --test tests/tests.js" + } +} diff --git a/tools/ui/node_modules/regenerate-unicode-properties/unicode-version.js b/tools/ui/node_modules/regenerate-unicode-properties/unicode-version.js new file mode 100644 index 0000000000000000000000000000000000000000..6699bd76e5fb8cd7b3ad11bde1862a16e39b544a --- /dev/null +++ b/tools/ui/node_modules/regenerate-unicode-properties/unicode-version.js @@ -0,0 +1 @@ +module.exports = '17.0.0'; diff --git a/tools/ui/node_modules/regenerate/LICENSE-MIT.txt b/tools/ui/node_modules/regenerate/LICENSE-MIT.txt new file mode 100644 index 0000000000000000000000000000000000000000..a41e0a7ef970ecdd83d82cd99bda97b22077bc62 --- /dev/null +++ b/tools/ui/node_modules/regenerate/LICENSE-MIT.txt @@ -0,0 +1,20 @@ +Copyright Mathias Bynens + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/regenerate/README.md b/tools/ui/node_modules/regenerate/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ec243ce3ba78ed01229a81a599f7cde4e8d1ef48 --- /dev/null +++ b/tools/ui/node_modules/regenerate/README.md @@ -0,0 +1,338 @@ +# Regenerate [![Build status](https://travis-ci.org/mathiasbynens/regenerate.svg?branch=master)](https://travis-ci.org/mathiasbynens/regenerate) [![Code coverage status](https://img.shields.io/codecov/c/github/mathiasbynens/regenerate.svg)](https://codecov.io/gh/mathiasbynens/regenerate) + +_Regenerate_ is a Unicode-aware regex generator for JavaScript. It allows you to easily generate ES5-compatible regular expressions based on a given set of Unicode symbols or code points. (This is trickier than you might think, because of [how JavaScript deals with astral symbols](https://mathiasbynens.be/notes/javascript-unicode).) + +## Installation + +Via [npm](https://npmjs.org/): + +```bash +npm install regenerate +``` + +Via [Bower](http://bower.io/): + +```bash +bower install regenerate +``` + +In a browser: + +```html + +``` + +In [Node.js](https://nodejs.org/), [io.js](https://iojs.org/), and [RingoJS ≥ v0.8.0](http://ringojs.org/): + +```js +var regenerate = require('regenerate'); +``` + +In [Narwhal](http://narwhaljs.org/) and [RingoJS ≤ v0.7.0](http://ringojs.org/): + +```js +var regenerate = require('regenerate').regenerate; +``` + +In [Rhino](http://www.mozilla.org/rhino/): + +```js +load('regenerate.js'); +``` + +Using an AMD loader like [RequireJS](http://requirejs.org/): + +```js +require( + { + 'paths': { + 'regenerate': 'path/to/regenerate' + } + }, + ['regenerate'], + function(regenerate) { + console.log(regenerate); + } +); +``` + +## API + +### `regenerate(value1, value2, value3, ...)` + +The main Regenerate function. Calling this function creates a new set that gets a chainable API. + +```js +var set = regenerate() + .addRange(0x60, 0x69) // add U+0060 to U+0069 + .remove(0x62, 0x64) // remove U+0062 and U+0064 + .add(0x1D306); // add U+1D306 +set.valueOf(); +// → [0x60, 0x61, 0x63, 0x65, 0x66, 0x67, 0x68, 0x69, 0x1D306] +set.toString(); +// → '[`ace-i]|\\uD834\\uDF06' +set.toRegExp(); +// → /[`ace-i]|\uD834\uDF06/ +``` + +Any arguments passed to `regenerate()` will be added to the set right away. Both code points (numbers) and symbols (strings consisting of a single Unicode symbol) are accepted, as well as arrays containing values of these types. + +```js +regenerate(0x1D306, 'A', '©', 0x2603).toString(); +// → '[A\\xA9\\u2603]|\\uD834\\uDF06' + +var items = [0x1D306, 'A', '©', 0x2603]; +regenerate(items).toString(); +// → '[A\\xA9\\u2603]|\\uD834\\uDF06' +``` + +### `regenerate.prototype.add(value1, value2, value3, ...)` + +Any arguments passed to `add()` are added to the set. Both code points (numbers) and symbols (strings consisting of a single Unicode symbol) are accepted, as well as arrays containing values of these types. + +```js +regenerate().add(0x1D306, 'A', '©', 0x2603).toString(); +// → '[A\\xA9\\u2603]|\\uD834\\uDF06' + +var items = [0x1D306, 'A', '©', 0x2603]; +regenerate().add(items).toString(); +// → '[A\\xA9\\u2603]|\\uD834\\uDF06' +``` + +It’s also possible to pass in a Regenerate instance. Doing so adds all code points in that instance to the current set. + +```js +var set = regenerate(0x1D306, 'A'); +regenerate().add('©', 0x2603).add(set).toString(); +// → '[A\\xA9\\u2603]|\\uD834\\uDF06' +``` + +Note that the initial call to `regenerate()` acts like `add()`. This allows you to create a new Regenerate instance and add some code points to it in one go: + +```js +regenerate(0x1D306, 'A', '©', 0x2603).toString(); +// → '[A\\xA9\\u2603]|\\uD834\\uDF06' +``` + +### `regenerate.prototype.remove(value1, value2, value3, ...)` + +Any arguments passed to `remove()` are removed from the set. Both code points (numbers) and symbols (strings consisting of a single Unicode symbol) are accepted, as well as arrays containing values of these types. + +```js +regenerate(0x1D306, 'A', '©', 0x2603).remove('☃').toString(); +// → '[A\\xA9]|\\uD834\\uDF06' +``` + +It’s also possible to pass in a Regenerate instance. Doing so removes all code points in that instance from the current set. + +```js +var set = regenerate('☃'); +regenerate(0x1D306, 'A', '©', 0x2603).remove(set).toString(); +// → '[A\\xA9]|\\uD834\\uDF06' +``` + +### `regenerate.prototype.addRange(start, end)` + +Adds a range of code points from `start` to `end` (inclusive) to the set. Both code points (numbers) and symbols (strings consisting of a single Unicode symbol) are accepted. + +```js +regenerate(0x1D306).addRange(0x00, 0xFF).toString(16); +// → '[\\0-\\xFF]|\\uD834\\uDF06' + +regenerate().addRange('A', 'z').toString(); +// → '[A-z]' +``` + +### `regenerate.prototype.removeRange(start, end)` + +Removes a range of code points from `start` to `end` (inclusive) from the set. Both code points (numbers) and symbols (strings consisting of a single Unicode symbol) are accepted. + +```js +regenerate() + .addRange(0x000000, 0x10FFFF) // add all Unicode code points + .removeRange('A', 'z') // remove all symbols from `A` to `z` + .toString(); +// → '[\\0-@\\{-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]' + +regenerate() + .addRange(0x000000, 0x10FFFF) // add all Unicode code points + .removeRange(0x0041, 0x007A) // remove all code points from U+0041 to U+007A + .toString(); +// → '[\\0-@\\{-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]' +``` + +### `regenerate.prototype.intersection(codePoints)` + +Removes any code points from the set that are not present in both the set and the given `codePoints` array. `codePoints` must be an array of numeric code point values, i.e. numbers. + +```js +regenerate() + .addRange(0x00, 0xFF) // add extended ASCII code points + .intersection([0x61, 0x69]) // remove all code points from the set except for these + .toString(); +// → '[ai]' +``` + +Instead of the `codePoints` array, it’s also possible to pass in a Regenerate instance. + +```js +var whitelist = regenerate(0x61, 0x69); + +regenerate() + .addRange(0x00, 0xFF) // add extended ASCII code points + .intersection(whitelist) // remove all code points from the set except for those in the `whitelist` set + .toString(); +// → '[ai]' +``` + +### `regenerate.prototype.contains(value)` + +Returns `true` if the given value is part of the set, and `false` otherwise. Both code points (numbers) and symbols (strings consisting of a single Unicode symbol) are accepted. + +```js +var set = regenerate().addRange(0x00, 0xFF); +set.contains('A'); +// → true +set.contains(0x1D306); +// → false +``` + +### `regenerate.prototype.clone()` + +Returns a clone of the current code point set. Any actions performed on the clone won’t mutate the original set. + +```js +var setA = regenerate(0x1D306); +var setB = setA.clone().add(0x1F4A9); +setA.toArray(); +// → [0x1D306] +setB.toArray(); +// → [0x1D306, 0x1F4A9] +``` + +### `regenerate.prototype.toString(options)` + +Returns a string representing (part of) a regular expression that matches all the symbols mapped to the code points within the set. + +```js +regenerate(0x1D306, 0x1F4A9).toString(); +// → '\\uD834\\uDF06|\\uD83D\\uDCA9' +``` + +If the `bmpOnly` property of the optional `options` object is set to `true`, the output matches surrogates individually, regardless of whether they’re lone surrogates or just part of a surrogate pair. This simplifies the output, but it can only be used in case you’re certain the strings it will be used on don’t contain any astral symbols. + +```js +var highSurrogates = regenerate().addRange(0xD800, 0xDBFF); +highSurrogates.toString(); +// → '[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])' +highSurrogates.toString({ 'bmpOnly': true }); +// → '[\\uD800-\\uDBFF]' + +var lowSurrogates = regenerate().addRange(0xDC00, 0xDFFF); +lowSurrogates.toString(); +// → '(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]' +lowSurrogates.toString({ 'bmpOnly': true }); +// → '[\\uDC00-\\uDFFF]' +``` + +Note that lone low surrogates cannot be matched accurately using regular expressions in JavaScript without the use of [lookbehind assertions](https://mathiasbynens.be/notes/es-regexp-proposals#lookbehinds), which aren't yet widely supported. Regenerate’s output makes a best-effort approach but [there can be false negatives in this regard](https://github.com/mathiasbynens/regenerate/issues/28#issuecomment-72224808). + +If the `hasUnicodeFlag` property of the optional `options` object is set to `true`, the output makes use of Unicode code point escapes (`\u{…}`) where applicable. This simplifies the output at the cost of compatibility and portability, since it means the output can only be used as a pattern in a regular expression with [the ES6 `u` flag](https://mathiasbynens.be/notes/es6-unicode-regex) enabled. + +```js +var set = regenerate().addRange(0x0, 0x10FFFF); + +set.toString(); +// → '[\\0-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]'' + +set.toString({ 'hasUnicodeFlag': true }); +// → '[\\0-\\u{10FFFF}]' +``` + +### `regenerate.prototype.toRegExp(flags = '')` + +Returns a regular expression that matches all the symbols mapped to the code points within the set. Optionally, you can pass [flags](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#Parameters) to be added to the regular expression. + +```js +var regex = regenerate(0x1D306, 0x1F4A9).toRegExp(); +// → /\uD834\uDF06|\uD83D\uDCA9/ +regex.test('𝌆'); +// → true +regex.test('A'); +// → false + +// With flags: +var regex = regenerate(0x1D306, 0x1F4A9).toRegExp('g'); +// → /\uD834\uDF06|\uD83D\uDCA9/g +``` + +**Note:** This probably shouldn’t be used. Regenerate is intended as a tool that is used as part of a build process, not at runtime. + +### `regenerate.prototype.valueOf()` or `regenerate.prototype.toArray()` + +Returns a sorted array of unique code points in the set. + +```js +regenerate(0x1D306) + .addRange(0x60, 0x65) + .add(0x59, 0x60) // note: 0x59 is added after 0x65, and 0x60 is a duplicate + .valueOf(); +// → [0x59, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x1D306] +``` + +### `regenerate.version` + +A string representing the semantic version number. + +## Combine Regenerate with other libraries + +Regenerate gets even better when combined with other libraries such as [Punycode.js](https://mths.be/punycode). Here’s an example where [Punycode.js](https://mths.be/punycode) is used to convert a string into an array of code points, that is then passed on to Regenerate: + +```js +var regenerate = require('regenerate'); +var punycode = require('punycode'); + +var string = 'Lorem ipsum dolor sit amet.'; +// Get an array of all code points used in the string: +var codePoints = punycode.ucs2.decode(string); + +// Generate a regular expression that matches any of the symbols used in the string: +regenerate(codePoints).toString(); +// → '[ \\.Ladeilmopr-u]' +``` + +In ES6 you can do something similar with [`Array.from`](https://mths.be/array-from) which uses [the string’s iterator](https://mathiasbynens.be/notes/javascript-unicode#iterating-over-symbols) to split the given string into an array of strings that each contain a single symbol. [`regenerate()`](#regenerateprototypeaddvalue1-value2-value3-) accepts both strings and code points, remember? + +```js +var regenerate = require('regenerate'); + +var string = 'Lorem ipsum dolor sit amet.'; +// Get an array of all symbols used in the string: +var symbols = Array.from(string); + +// Generate a regular expression that matches any of the symbols used in the string: +regenerate(symbols).toString(); +// → '[ \\.Ladeilmopr-u]' +``` + +## Support + +Regenerate supports at least Chrome 27+, Firefox 3+, Safari 4+, Opera 10+, IE 6+, Node.js v0.10.0+, io.js v1.0.0+, Narwhal 0.3.2+, RingoJS 0.8+, PhantomJS 1.9.0+, and Rhino 1.7RC4+. + +## Unit tests & code coverage + +After cloning this repository, run `npm install` to install the dependencies needed for Regenerate development and testing. You may want to install Istanbul _globally_ using `npm install istanbul -g`. + +Once that’s done, you can run the unit tests in Node using `npm test` or `node tests/tests.js`. To run the tests in Rhino, Ringo, Narwhal, and web browsers as well, use `grunt test`. + +To generate the code coverage report, use `grunt cover`. + +## Author + +| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") | +|---| +| [Mathias Bynens](https://mathiasbynens.be/) | + +## License + +Regenerate is available under the [MIT](https://mths.be/mit) license. diff --git a/tools/ui/node_modules/regenerate/package.json b/tools/ui/node_modules/regenerate/package.json new file mode 100644 index 0000000000000000000000000000000000000000..42b485a44ffdec956122141a221c01225e2b8349 --- /dev/null +++ b/tools/ui/node_modules/regenerate/package.json @@ -0,0 +1,38 @@ +{ + "name": "regenerate", + "version": "1.4.2", + "description": "Generate JavaScript-compatible regular expressions based on a given set of Unicode symbols or code points.", + "homepage": "https://mths.be/regenerate", + "main": "regenerate.js", + "keywords": [ + "regex", + "regexp", + "javascript", + "unicode", + "generator", + "tool" + ], + "license": "MIT", + "author": { + "name": "Mathias Bynens", + "url": "https://mathiasbynens.be/" + }, + "repository": { + "type": "git", + "url": "https://github.com/mathiasbynens/regenerate.git" + }, + "bugs": "https://github.com/mathiasbynens/regenerate/issues", + "scripts": { + "cover": "istanbul cover --report html --verbose --dir coverage tests/tests.js", + "test": "node tests/tests.js" + }, + "devDependencies": { + "codecov": "^1.0.1", + "grunt": "^0.4.5", + "grunt-shell": "^1.1.1", + "istanbul": "^0.4.3", + "qunit-extras": "^1.1.0", + "qunitjs": "~1.11.0", + "requirejs": "^2.1.15" + } +} diff --git a/tools/ui/node_modules/regenerate/regenerate.js b/tools/ui/node_modules/regenerate/regenerate.js new file mode 100644 index 0000000000000000000000000000000000000000..0686adef63b17cebf3187041b477955e9a19749e --- /dev/null +++ b/tools/ui/node_modules/regenerate/regenerate.js @@ -0,0 +1,1209 @@ +/*! https://mths.be/regenerate v1.4.2 by @mathias | MIT license */ +;(function(root) { + + // Detect free variables `exports`. + var freeExports = typeof exports == 'object' && exports; + + // Detect free variable `module`. + var freeModule = typeof module == 'object' && module && + module.exports == freeExports && module; + + // Detect free variable `global`, from Node.js/io.js or Browserified code, + // and use it as `root`. + var freeGlobal = typeof global == 'object' && global; + if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) { + root = freeGlobal; + } + + /*--------------------------------------------------------------------------*/ + + var ERRORS = { + 'rangeOrder': 'A range\u2019s `stop` value must be greater than or equal ' + + 'to the `start` value.', + 'codePointRange': 'Invalid code point value. Code points range from ' + + 'U+000000 to U+10FFFF.' + }; + + // https://mathiasbynens.be/notes/javascript-encoding#surrogate-pairs + var HIGH_SURROGATE_MIN = 0xD800; + var HIGH_SURROGATE_MAX = 0xDBFF; + var LOW_SURROGATE_MIN = 0xDC00; + var LOW_SURROGATE_MAX = 0xDFFF; + + // In Regenerate output, `\0` is never preceded by `\` because we sort by + // code point value, so let’s keep this regular expression simple. + var regexNull = /\\x00([^0123456789]|$)/g; + + var object = {}; + var hasOwnProperty = object.hasOwnProperty; + var extend = function(destination, source) { + var key; + for (key in source) { + if (hasOwnProperty.call(source, key)) { + destination[key] = source[key]; + } + } + return destination; + }; + + var forEach = function(array, callback) { + var index = -1; + var length = array.length; + while (++index < length) { + callback(array[index], index); + } + }; + + var toString = object.toString; + var isArray = function(value) { + return toString.call(value) == '[object Array]'; + }; + var isNumber = function(value) { + return typeof value == 'number' || + toString.call(value) == '[object Number]'; + }; + + // This assumes that `number` is a positive integer that `toString()`s nicely + // (which is the case for all code point values). + var zeroes = '0000'; + var pad = function(number, totalCharacters) { + var string = String(number); + return string.length < totalCharacters + ? (zeroes + string).slice(-totalCharacters) + : string; + }; + + var hex = function(number) { + return Number(number).toString(16).toUpperCase(); + }; + + var slice = [].slice; + + /*--------------------------------------------------------------------------*/ + + var dataFromCodePoints = function(codePoints) { + var index = -1; + var length = codePoints.length; + var max = length - 1; + var result = []; + var isStart = true; + var tmp; + var previous = 0; + while (++index < length) { + tmp = codePoints[index]; + if (isStart) { + result.push(tmp); + previous = tmp; + isStart = false; + } else { + if (tmp == previous + 1) { + if (index != max) { + previous = tmp; + continue; + } else { + isStart = true; + result.push(tmp + 1); + } + } else { + // End the previous range and start a new one. + result.push(previous + 1, tmp); + previous = tmp; + } + } + } + if (!isStart) { + result.push(tmp + 1); + } + return result; + }; + + var dataRemove = function(data, codePoint) { + // Iterate over the data per `(start, end)` pair. + var index = 0; + var start; + var end; + var length = data.length; + while (index < length) { + start = data[index]; + end = data[index + 1]; + if (codePoint >= start && codePoint < end) { + // Modify this pair. + if (codePoint == start) { + if (end == start + 1) { + // Just remove `start` and `end`. + data.splice(index, 2); + return data; + } else { + // Just replace `start` with a new value. + data[index] = codePoint + 1; + return data; + } + } else if (codePoint == end - 1) { + // Just replace `end` with a new value. + data[index + 1] = codePoint; + return data; + } else { + // Replace `[start, end]` with `[startA, endA, startB, endB]`. + data.splice(index, 2, start, codePoint, codePoint + 1, end); + return data; + } + } + index += 2; + } + return data; + }; + + var dataRemoveRange = function(data, rangeStart, rangeEnd) { + if (rangeEnd < rangeStart) { + throw Error(ERRORS.rangeOrder); + } + // Iterate over the data per `(start, end)` pair. + var index = 0; + var start; + var end; + while (index < data.length) { + start = data[index]; + end = data[index + 1] - 1; // Note: the `- 1` makes `end` inclusive. + + // Exit as soon as no more matching pairs can be found. + if (start > rangeEnd) { + return data; + } + + // Check if this range pair is equal to, or forms a subset of, the range + // to be removed. + // E.g. we have `[0, 11, 40, 51]` and want to remove 0-10 → `[40, 51]`. + // E.g. we have `[40, 51]` and want to remove 0-100 → `[]`. + if (rangeStart <= start && rangeEnd >= end) { + // Remove this pair. + data.splice(index, 2); + continue; + } + + // Check if both `rangeStart` and `rangeEnd` are within the bounds of + // this pair. + // E.g. we have `[0, 11]` and want to remove 4-6 → `[0, 4, 7, 11]`. + if (rangeStart >= start && rangeEnd < end) { + if (rangeStart == start) { + // Replace `[start, end]` with `[startB, endB]`. + data[index] = rangeEnd + 1; + data[index + 1] = end + 1; + return data; + } + // Replace `[start, end]` with `[startA, endA, startB, endB]`. + data.splice(index, 2, start, rangeStart, rangeEnd + 1, end + 1); + return data; + } + + // Check if only `rangeStart` is within the bounds of this pair. + // E.g. we have `[0, 11]` and want to remove 4-20 → `[0, 4]`. + if (rangeStart >= start && rangeStart <= end) { + // Replace `end` with `rangeStart`. + data[index + 1] = rangeStart; + // Note: we cannot `return` just yet, in case any following pairs still + // contain matching code points. + // E.g. we have `[0, 11, 14, 31]` and want to remove 4-20 + // → `[0, 4, 21, 31]`. + } + + // Check if only `rangeEnd` is within the bounds of this pair. + // E.g. we have `[14, 31]` and want to remove 4-20 → `[21, 31]`. + else if (rangeEnd >= start && rangeEnd <= end) { + // Just replace `start`. + data[index] = rangeEnd + 1; + return data; + } + + index += 2; + } + return data; + }; + + var dataAdd = function(data, codePoint) { + // Iterate over the data per `(start, end)` pair. + var index = 0; + var start; + var end; + var lastIndex = null; + var length = data.length; + if (codePoint < 0x0 || codePoint > 0x10FFFF) { + throw RangeError(ERRORS.codePointRange); + } + while (index < length) { + start = data[index]; + end = data[index + 1]; + + // Check if the code point is already in the set. + if (codePoint >= start && codePoint < end) { + return data; + } + + if (codePoint == start - 1) { + // Just replace `start` with a new value. + data[index] = codePoint; + return data; + } + + // At this point, if `start` is `greater` than `codePoint`, insert a new + // `[start, end]` pair before the current pair, or after the current pair + // if there is a known `lastIndex`. + if (start > codePoint) { + data.splice( + lastIndex != null ? lastIndex + 2 : 0, + 0, + codePoint, + codePoint + 1 + ); + return data; + } + + if (codePoint == end) { + // Check if adding this code point causes two separate ranges to become + // a single range, e.g. `dataAdd([0, 4, 5, 10], 4)` → `[0, 10]`. + if (codePoint + 1 == data[index + 2]) { + data.splice(index, 4, start, data[index + 3]); + return data; + } + // Else, just replace `end` with a new value. + data[index + 1] = codePoint + 1; + return data; + } + lastIndex = index; + index += 2; + } + // The loop has finished; add the new pair to the end of the data set. + data.push(codePoint, codePoint + 1); + return data; + }; + + var dataAddData = function(dataA, dataB) { + // Iterate over the data per `(start, end)` pair. + var index = 0; + var start; + var end; + var data = dataA.slice(); + var length = dataB.length; + while (index < length) { + start = dataB[index]; + end = dataB[index + 1] - 1; + if (start == end) { + data = dataAdd(data, start); + } else { + data = dataAddRange(data, start, end); + } + index += 2; + } + return data; + }; + + var dataRemoveData = function(dataA, dataB) { + // Iterate over the data per `(start, end)` pair. + var index = 0; + var start; + var end; + var data = dataA.slice(); + var length = dataB.length; + while (index < length) { + start = dataB[index]; + end = dataB[index + 1] - 1; + if (start == end) { + data = dataRemove(data, start); + } else { + data = dataRemoveRange(data, start, end); + } + index += 2; + } + return data; + }; + + var dataAddRange = function(data, rangeStart, rangeEnd) { + if (rangeEnd < rangeStart) { + throw Error(ERRORS.rangeOrder); + } + if ( + rangeStart < 0x0 || rangeStart > 0x10FFFF || + rangeEnd < 0x0 || rangeEnd > 0x10FFFF + ) { + throw RangeError(ERRORS.codePointRange); + } + // Iterate over the data per `(start, end)` pair. + var index = 0; + var start; + var end; + var added = false; + var length = data.length; + while (index < length) { + start = data[index]; + end = data[index + 1]; + + if (added) { + // The range has already been added to the set; at this point, we just + // need to get rid of the following ranges in case they overlap. + + // Check if this range can be combined with the previous range. + if (start == rangeEnd + 1) { + data.splice(index - 1, 2); + return data; + } + + // Exit as soon as no more possibly overlapping pairs can be found. + if (start > rangeEnd) { + return data; + } + + // E.g. `[0, 11, 12, 16]` and we’ve added 5-15, so we now have + // `[0, 16, 12, 16]`. Remove the `12,16` part, as it lies within the + // `0,16` range that was previously added. + if (start >= rangeStart && start <= rangeEnd) { + // `start` lies within the range that was previously added. + + if (end > rangeStart && end - 1 <= rangeEnd) { + // `end` lies within the range that was previously added as well, + // so remove this pair. + data.splice(index, 2); + index -= 2; + // Note: we cannot `return` just yet, as there may still be other + // overlapping pairs. + } else { + // `start` lies within the range that was previously added, but + // `end` doesn’t. E.g. `[0, 11, 12, 31]` and we’ve added 5-15, so + // now we have `[0, 16, 12, 31]`. This must be written as `[0, 31]`. + // Remove the previously added `end` and the current `start`. + data.splice(index - 1, 2); + index -= 2; + } + + // Note: we cannot return yet. + } + + } + + else if (start == rangeEnd + 1 || start == rangeEnd) { + data[index] = rangeStart; + return data; + } + + // Check if a new pair must be inserted *before* the current one. + else if (start > rangeEnd) { + data.splice(index, 0, rangeStart, rangeEnd + 1); + return data; + } + + else if (rangeStart >= start && rangeStart < end && rangeEnd + 1 <= end) { + // The new range lies entirely within an existing range pair. No action + // needed. + return data; + } + + else if ( + // E.g. `[0, 11]` and you add 5-15 → `[0, 16]`. + (rangeStart >= start && rangeStart < end) || + // E.g. `[0, 3]` and you add 3-6 → `[0, 7]`. + end == rangeStart + ) { + // Replace `end` with the new value. + data[index + 1] = rangeEnd + 1; + // Make sure the next range pair doesn’t overlap, e.g. `[0, 11, 12, 14]` + // and you add 5-15 → `[0, 16]`, i.e. remove the `12,14` part. + added = true; + // Note: we cannot `return` just yet. + } + + else if (rangeStart <= start && rangeEnd + 1 >= end) { + // The new range is a superset of the old range. + data[index] = rangeStart; + data[index + 1] = rangeEnd + 1; + added = true; + } + + index += 2; + } + // The loop has finished without doing anything; add the new pair to the end + // of the data set. + if (!added) { + data.push(rangeStart, rangeEnd + 1); + } + return data; + }; + + var dataContains = function(data, codePoint) { + var index = 0; + var length = data.length; + // Exit early if `codePoint` is not within `data`’s overall range. + var start = data[index]; + var end = data[length - 1]; + if (length >= 2) { + if (codePoint < start || codePoint > end) { + return false; + } + } + // Iterate over the data per `(start, end)` pair. + while (index < length) { + start = data[index]; + end = data[index + 1]; + if (codePoint >= start && codePoint < end) { + return true; + } + index += 2; + } + return false; + }; + + var dataIntersection = function(data, codePoints) { + var index = 0; + var length = codePoints.length; + var codePoint; + var result = []; + while (index < length) { + codePoint = codePoints[index]; + if (dataContains(data, codePoint)) { + result.push(codePoint); + } + ++index; + } + return dataFromCodePoints(result); + }; + + var dataIsEmpty = function(data) { + return !data.length; + }; + + var dataIsSingleton = function(data) { + // Check if the set only represents a single code point. + return data.length == 2 && data[0] + 1 == data[1]; + }; + + var dataToArray = function(data) { + // Iterate over the data per `(start, end)` pair. + var index = 0; + var start; + var end; + var result = []; + var length = data.length; + while (index < length) { + start = data[index]; + end = data[index + 1]; + while (start < end) { + result.push(start); + ++start; + } + index += 2; + } + return result; + }; + + /*--------------------------------------------------------------------------*/ + + // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + var floor = Math.floor; + var highSurrogate = function(codePoint) { + return parseInt( + floor((codePoint - 0x10000) / 0x400) + HIGH_SURROGATE_MIN, + 10 + ); + }; + + var lowSurrogate = function(codePoint) { + return parseInt( + (codePoint - 0x10000) % 0x400 + LOW_SURROGATE_MIN, + 10 + ); + }; + + var stringFromCharCode = String.fromCharCode; + var codePointToString = function(codePoint) { + var string; + // https://mathiasbynens.be/notes/javascript-escapes#single + // Note: the `\b` escape sequence for U+0008 BACKSPACE in strings has a + // different meaning in regular expressions (word boundary), so it cannot + // be used here. + if (codePoint == 0x09) { + string = '\\t'; + } + // Note: IE < 9 treats `'\v'` as `'v'`, so avoid using it. + // else if (codePoint == 0x0B) { + // string = '\\v'; + // } + else if (codePoint == 0x0A) { + string = '\\n'; + } + else if (codePoint == 0x0C) { + string = '\\f'; + } + else if (codePoint == 0x0D) { + string = '\\r'; + } + else if (codePoint == 0x2D) { + // https://mathiasbynens.be/notes/javascript-escapes#hexadecimal + // Note: `-` (U+002D HYPHEN-MINUS) is escaped in this way rather + // than by backslash-escaping, in case the output is used outside + // of a character class in a `u` RegExp. /\-/u throws, but + // /\x2D/u is fine. + string = '\\x2D'; + } + else if (codePoint == 0x5C) { + string = '\\\\'; + } + else if ( + codePoint == 0x24 || + (codePoint >= 0x28 && codePoint <= 0x2B) || + codePoint == 0x2E || codePoint == 0x2F || + codePoint == 0x3F || + (codePoint >= 0x5B && codePoint <= 0x5E) || + (codePoint >= 0x7B && codePoint <= 0x7D) + ) { + // The code point maps to an unsafe printable ASCII character; + // backslash-escape it. Here’s the list of those symbols: + // + // $()*+./?[\]^{|} + // + // This matches SyntaxCharacters as well as `/` (U+002F SOLIDUS). + // https://tc39.github.io/ecma262/#prod-SyntaxCharacter + string = '\\' + stringFromCharCode(codePoint); + } + else if (codePoint >= 0x20 && codePoint <= 0x7E) { + // The code point maps to one of these printable ASCII symbols + // (including the space character): + // + // !"#%&',/0123456789:;<=>@ABCDEFGHIJKLMNO + // PQRSTUVWXYZ_`abcdefghijklmnopqrstuvwxyz~ + // + // These can safely be used directly. + string = stringFromCharCode(codePoint); + } + else if (codePoint <= 0xFF) { + string = '\\x' + pad(hex(codePoint), 2); + } + else { // `codePoint <= 0xFFFF` holds true. + // https://mathiasbynens.be/notes/javascript-escapes#unicode + string = '\\u' + pad(hex(codePoint), 4); + } + + // There’s no need to account for astral symbols / surrogate pairs here, + // since `codePointToString` is private and only used for BMP code points. + // But if that’s what you need, just add an `else` block with this code: + // + // string = '\\u' + pad(hex(highSurrogate(codePoint)), 4) + // + '\\u' + pad(hex(lowSurrogate(codePoint)), 4); + + return string; + }; + + var codePointToStringUnicode = function(codePoint) { + if (codePoint <= 0xFFFF) { + return codePointToString(codePoint); + } + return '\\u{' + codePoint.toString(16).toUpperCase() + '}'; + }; + + var symbolToCodePoint = function(symbol) { + var length = symbol.length; + var first = symbol.charCodeAt(0); + var second; + if ( + first >= HIGH_SURROGATE_MIN && first <= HIGH_SURROGATE_MAX && + length > 1 // There is a next code unit. + ) { + // `first` is a high surrogate, and there is a next character. Assume + // it’s a low surrogate (else it’s invalid usage of Regenerate anyway). + second = symbol.charCodeAt(1); + // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + return (first - HIGH_SURROGATE_MIN) * 0x400 + + second - LOW_SURROGATE_MIN + 0x10000; + } + return first; + }; + + var createBMPCharacterClasses = function(data) { + // Iterate over the data per `(start, end)` pair. + var result = ''; + var index = 0; + var start; + var end; + var length = data.length; + if (dataIsSingleton(data)) { + return codePointToString(data[0]); + } + while (index < length) { + start = data[index]; + end = data[index + 1] - 1; // Note: the `- 1` makes `end` inclusive. + if (start == end) { + result += codePointToString(start); + } else if (start + 1 == end) { + result += codePointToString(start) + codePointToString(end); + } else { + result += codePointToString(start) + '-' + codePointToString(end); + } + index += 2; + } + return '[' + result + ']'; + }; + + var createUnicodeCharacterClasses = function(data) { + // Iterate over the data per `(start, end)` pair. + var result = ''; + var index = 0; + var start; + var end; + var length = data.length; + if (dataIsSingleton(data)) { + return codePointToStringUnicode(data[0]); + } + while (index < length) { + start = data[index]; + end = data[index + 1] - 1; // Note: the `- 1` makes `end` inclusive. + if (start == end) { + result += codePointToStringUnicode(start); + } else if (start + 1 == end) { + result += codePointToStringUnicode(start) + codePointToStringUnicode(end); + } else { + result += codePointToStringUnicode(start) + '-' + codePointToStringUnicode(end); + } + index += 2; + } + return '[' + result + ']'; + }; + + var splitAtBMP = function(data) { + // Iterate over the data per `(start, end)` pair. + var loneHighSurrogates = []; + var loneLowSurrogates = []; + var bmp = []; + var astral = []; + var index = 0; + var start; + var end; + var length = data.length; + while (index < length) { + start = data[index]; + end = data[index + 1] - 1; // Note: the `- 1` makes `end` inclusive. + + if (start < HIGH_SURROGATE_MIN) { + + // The range starts and ends before the high surrogate range. + // E.g. (0, 0x10). + if (end < HIGH_SURROGATE_MIN) { + bmp.push(start, end + 1); + } + + // The range starts before the high surrogate range and ends within it. + // E.g. (0, 0xD855). + if (end >= HIGH_SURROGATE_MIN && end <= HIGH_SURROGATE_MAX) { + bmp.push(start, HIGH_SURROGATE_MIN); + loneHighSurrogates.push(HIGH_SURROGATE_MIN, end + 1); + } + + // The range starts before the high surrogate range and ends in the low + // surrogate range. E.g. (0, 0xDCFF). + if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) { + bmp.push(start, HIGH_SURROGATE_MIN); + loneHighSurrogates.push(HIGH_SURROGATE_MIN, HIGH_SURROGATE_MAX + 1); + loneLowSurrogates.push(LOW_SURROGATE_MIN, end + 1); + } + + // The range starts before the high surrogate range and ends after the + // low surrogate range. E.g. (0, 0x10FFFF). + if (end > LOW_SURROGATE_MAX) { + bmp.push(start, HIGH_SURROGATE_MIN); + loneHighSurrogates.push(HIGH_SURROGATE_MIN, HIGH_SURROGATE_MAX + 1); + loneLowSurrogates.push(LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1); + if (end <= 0xFFFF) { + bmp.push(LOW_SURROGATE_MAX + 1, end + 1); + } else { + bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1); + astral.push(0xFFFF + 1, end + 1); + } + } + + } else if (start >= HIGH_SURROGATE_MIN && start <= HIGH_SURROGATE_MAX) { + + // The range starts and ends in the high surrogate range. + // E.g. (0xD855, 0xD866). + if (end >= HIGH_SURROGATE_MIN && end <= HIGH_SURROGATE_MAX) { + loneHighSurrogates.push(start, end + 1); + } + + // The range starts in the high surrogate range and ends in the low + // surrogate range. E.g. (0xD855, 0xDCFF). + if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) { + loneHighSurrogates.push(start, HIGH_SURROGATE_MAX + 1); + loneLowSurrogates.push(LOW_SURROGATE_MIN, end + 1); + } + + // The range starts in the high surrogate range and ends after the low + // surrogate range. E.g. (0xD855, 0x10FFFF). + if (end > LOW_SURROGATE_MAX) { + loneHighSurrogates.push(start, HIGH_SURROGATE_MAX + 1); + loneLowSurrogates.push(LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1); + if (end <= 0xFFFF) { + bmp.push(LOW_SURROGATE_MAX + 1, end + 1); + } else { + bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1); + astral.push(0xFFFF + 1, end + 1); + } + } + + } else if (start >= LOW_SURROGATE_MIN && start <= LOW_SURROGATE_MAX) { + + // The range starts and ends in the low surrogate range. + // E.g. (0xDCFF, 0xDDFF). + if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) { + loneLowSurrogates.push(start, end + 1); + } + + // The range starts in the low surrogate range and ends after the low + // surrogate range. E.g. (0xDCFF, 0x10FFFF). + if (end > LOW_SURROGATE_MAX) { + loneLowSurrogates.push(start, LOW_SURROGATE_MAX + 1); + if (end <= 0xFFFF) { + bmp.push(LOW_SURROGATE_MAX + 1, end + 1); + } else { + bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1); + astral.push(0xFFFF + 1, end + 1); + } + } + + } else if (start > LOW_SURROGATE_MAX && start <= 0xFFFF) { + + // The range starts and ends after the low surrogate range. + // E.g. (0xFFAA, 0x10FFFF). + if (end <= 0xFFFF) { + bmp.push(start, end + 1); + } else { + bmp.push(start, 0xFFFF + 1); + astral.push(0xFFFF + 1, end + 1); + } + + } else { + + // The range starts and ends in the astral range. + astral.push(start, end + 1); + + } + + index += 2; + } + return { + 'loneHighSurrogates': loneHighSurrogates, + 'loneLowSurrogates': loneLowSurrogates, + 'bmp': bmp, + 'astral': astral + }; + }; + + var optimizeSurrogateMappings = function(surrogateMappings) { + var result = []; + var tmpLow = []; + var addLow = false; + var mapping; + var nextMapping; + var highSurrogates; + var lowSurrogates; + var nextHighSurrogates; + var nextLowSurrogates; + var index = -1; + var length = surrogateMappings.length; + while (++index < length) { + mapping = surrogateMappings[index]; + nextMapping = surrogateMappings[index + 1]; + if (!nextMapping) { + result.push(mapping); + continue; + } + highSurrogates = mapping[0]; + lowSurrogates = mapping[1]; + nextHighSurrogates = nextMapping[0]; + nextLowSurrogates = nextMapping[1]; + + // Check for identical high surrogate ranges. + tmpLow = lowSurrogates; + while ( + nextHighSurrogates && + highSurrogates[0] == nextHighSurrogates[0] && + highSurrogates[1] == nextHighSurrogates[1] + ) { + // Merge with the next item. + if (dataIsSingleton(nextLowSurrogates)) { + tmpLow = dataAdd(tmpLow, nextLowSurrogates[0]); + } else { + tmpLow = dataAddRange( + tmpLow, + nextLowSurrogates[0], + nextLowSurrogates[1] - 1 + ); + } + ++index; + mapping = surrogateMappings[index]; + highSurrogates = mapping[0]; + lowSurrogates = mapping[1]; + nextMapping = surrogateMappings[index + 1]; + nextHighSurrogates = nextMapping && nextMapping[0]; + nextLowSurrogates = nextMapping && nextMapping[1]; + addLow = true; + } + result.push([ + highSurrogates, + addLow ? tmpLow : lowSurrogates + ]); + addLow = false; + } + return optimizeByLowSurrogates(result); + }; + + var optimizeByLowSurrogates = function(surrogateMappings) { + if (surrogateMappings.length == 1) { + return surrogateMappings; + } + var index = -1; + var innerIndex = -1; + while (++index < surrogateMappings.length) { + var mapping = surrogateMappings[index]; + var lowSurrogates = mapping[1]; + var lowSurrogateStart = lowSurrogates[0]; + var lowSurrogateEnd = lowSurrogates[1]; + innerIndex = index; // Note: the loop starts at the next index. + while (++innerIndex < surrogateMappings.length) { + var otherMapping = surrogateMappings[innerIndex]; + var otherLowSurrogates = otherMapping[1]; + var otherLowSurrogateStart = otherLowSurrogates[0]; + var otherLowSurrogateEnd = otherLowSurrogates[1]; + if ( + lowSurrogateStart == otherLowSurrogateStart && + lowSurrogateEnd == otherLowSurrogateEnd && + otherLowSurrogates.length === 2 + ) { + // Add the code points in the other item to this one. + if (dataIsSingleton(otherMapping[0])) { + mapping[0] = dataAdd(mapping[0], otherMapping[0][0]); + } else { + mapping[0] = dataAddRange( + mapping[0], + otherMapping[0][0], + otherMapping[0][1] - 1 + ); + } + // Remove the other, now redundant, item. + surrogateMappings.splice(innerIndex, 1); + --innerIndex; + } + } + } + return surrogateMappings; + }; + + var surrogateSet = function(data) { + // Exit early if `data` is an empty set. + if (!data.length) { + return []; + } + + // Iterate over the data per `(start, end)` pair. + var index = 0; + var start; + var end; + var startHigh; + var startLow; + var endHigh; + var endLow; + var surrogateMappings = []; + var length = data.length; + while (index < length) { + start = data[index]; + end = data[index + 1] - 1; + + startHigh = highSurrogate(start); + startLow = lowSurrogate(start); + endHigh = highSurrogate(end); + endLow = lowSurrogate(end); + + var startsWithLowestLowSurrogate = startLow == LOW_SURROGATE_MIN; + var endsWithHighestLowSurrogate = endLow == LOW_SURROGATE_MAX; + var complete = false; + + // Append the previous high-surrogate-to-low-surrogate mappings. + // Step 1: `(startHigh, startLow)` to `(startHigh, LOW_SURROGATE_MAX)`. + if ( + startHigh == endHigh || + startsWithLowestLowSurrogate && endsWithHighestLowSurrogate + ) { + surrogateMappings.push([ + [startHigh, endHigh + 1], + [startLow, endLow + 1] + ]); + complete = true; + } else { + surrogateMappings.push([ + [startHigh, startHigh + 1], + [startLow, LOW_SURROGATE_MAX + 1] + ]); + } + + // Step 2: `(startHigh + 1, LOW_SURROGATE_MIN)` to + // `(endHigh - 1, LOW_SURROGATE_MAX)`. + if (!complete && startHigh + 1 < endHigh) { + if (endsWithHighestLowSurrogate) { + // Combine step 2 and step 3. + surrogateMappings.push([ + [startHigh + 1, endHigh + 1], + [LOW_SURROGATE_MIN, endLow + 1] + ]); + complete = true; + } else { + surrogateMappings.push([ + [startHigh + 1, endHigh], + [LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1] + ]); + } + } + + // Step 3. `(endHigh, LOW_SURROGATE_MIN)` to `(endHigh, endLow)`. + if (!complete) { + surrogateMappings.push([ + [endHigh, endHigh + 1], + [LOW_SURROGATE_MIN, endLow + 1] + ]); + } + + index += 2; + } + + // The format of `surrogateMappings` is as follows: + // + // [ surrogateMapping1, surrogateMapping2 ] + // + // i.e.: + // + // [ + // [ highSurrogates1, lowSurrogates1 ], + // [ highSurrogates2, lowSurrogates2 ] + // ] + return optimizeSurrogateMappings(surrogateMappings); + }; + + var createSurrogateCharacterClasses = function(surrogateMappings) { + var result = []; + forEach(surrogateMappings, function(surrogateMapping) { + var highSurrogates = surrogateMapping[0]; + var lowSurrogates = surrogateMapping[1]; + result.push( + createBMPCharacterClasses(highSurrogates) + + createBMPCharacterClasses(lowSurrogates) + ); + }); + return result.join('|'); + }; + + var createCharacterClassesFromData = function(data, bmpOnly, hasUnicodeFlag) { + if (hasUnicodeFlag) { + return createUnicodeCharacterClasses(data); + } + var result = []; + + var parts = splitAtBMP(data); + var loneHighSurrogates = parts.loneHighSurrogates; + var loneLowSurrogates = parts.loneLowSurrogates; + var bmp = parts.bmp; + var astral = parts.astral; + var hasLoneHighSurrogates = !dataIsEmpty(loneHighSurrogates); + var hasLoneLowSurrogates = !dataIsEmpty(loneLowSurrogates); + + var surrogateMappings = surrogateSet(astral); + + if (bmpOnly) { + bmp = dataAddData(bmp, loneHighSurrogates); + hasLoneHighSurrogates = false; + bmp = dataAddData(bmp, loneLowSurrogates); + hasLoneLowSurrogates = false; + } + + if (!dataIsEmpty(bmp)) { + // The data set contains BMP code points that are not high surrogates + // needed for astral code points in the set. + result.push(createBMPCharacterClasses(bmp)); + } + if (surrogateMappings.length) { + // The data set contains astral code points; append character classes + // based on their surrogate pairs. + result.push(createSurrogateCharacterClasses(surrogateMappings)); + } + // https://gist.github.com/mathiasbynens/bbe7f870208abcfec860 + if (hasLoneHighSurrogates) { + result.push( + createBMPCharacterClasses(loneHighSurrogates) + + // Make sure the high surrogates aren’t part of a surrogate pair. + '(?![\\uDC00-\\uDFFF])' + ); + } + if (hasLoneLowSurrogates) { + result.push( + // It is not possible to accurately assert the low surrogates aren’t + // part of a surrogate pair, since JavaScript regular expressions do + // not support lookbehind. + '(?:[^\\uD800-\\uDBFF]|^)' + + createBMPCharacterClasses(loneLowSurrogates) + ); + } + return result.join('|'); + }; + + /*--------------------------------------------------------------------------*/ + + // `regenerate` can be used as a constructor (and new methods can be added to + // its prototype) but also as a regular function, the latter of which is the + // documented and most common usage. For that reason, it’s not capitalized. + var regenerate = function(value) { + if (arguments.length > 1) { + value = slice.call(arguments); + } + if (this instanceof regenerate) { + this.data = []; + return value ? this.add(value) : this; + } + return (new regenerate).add(value); + }; + + regenerate.version = '1.4.2'; + + var proto = regenerate.prototype; + extend(proto, { + 'add': function(value) { + var $this = this; + if (value == null) { + return $this; + } + if (value instanceof regenerate) { + // Allow passing other Regenerate instances. + $this.data = dataAddData($this.data, value.data); + return $this; + } + if (arguments.length > 1) { + value = slice.call(arguments); + } + if (isArray(value)) { + forEach(value, function(item) { + $this.add(item); + }); + return $this; + } + $this.data = dataAdd( + $this.data, + isNumber(value) ? value : symbolToCodePoint(value) + ); + return $this; + }, + 'remove': function(value) { + var $this = this; + if (value == null) { + return $this; + } + if (value instanceof regenerate) { + // Allow passing other Regenerate instances. + $this.data = dataRemoveData($this.data, value.data); + return $this; + } + if (arguments.length > 1) { + value = slice.call(arguments); + } + if (isArray(value)) { + forEach(value, function(item) { + $this.remove(item); + }); + return $this; + } + $this.data = dataRemove( + $this.data, + isNumber(value) ? value : symbolToCodePoint(value) + ); + return $this; + }, + 'addRange': function(start, end) { + var $this = this; + $this.data = dataAddRange($this.data, + isNumber(start) ? start : symbolToCodePoint(start), + isNumber(end) ? end : symbolToCodePoint(end) + ); + return $this; + }, + 'removeRange': function(start, end) { + var $this = this; + var startCodePoint = isNumber(start) ? start : symbolToCodePoint(start); + var endCodePoint = isNumber(end) ? end : symbolToCodePoint(end); + $this.data = dataRemoveRange( + $this.data, + startCodePoint, + endCodePoint + ); + return $this; + }, + 'intersection': function(argument) { + var $this = this; + // Allow passing other Regenerate instances. + // TODO: Optimize this by writing and using `dataIntersectionData()`. + var array = argument instanceof regenerate ? + dataToArray(argument.data) : + argument; + $this.data = dataIntersection($this.data, array); + return $this; + }, + 'contains': function(codePoint) { + return dataContains( + this.data, + isNumber(codePoint) ? codePoint : symbolToCodePoint(codePoint) + ); + }, + 'clone': function() { + var set = new regenerate; + set.data = this.data.slice(0); + return set; + }, + 'toString': function(options) { + var result = createCharacterClassesFromData( + this.data, + options ? options.bmpOnly : false, + options ? options.hasUnicodeFlag : false + ); + if (!result) { + // For an empty set, return something that can be inserted `/here/` to + // form a valid regular expression. Avoid `(?:)` since that matches the + // empty string. + return '[]'; + } + // Use `\0` instead of `\x00` where possible. + return result.replace(regexNull, '\\0$1'); + }, + 'toRegExp': function(flags) { + var pattern = this.toString( + flags && flags.indexOf('u') != -1 ? + { 'hasUnicodeFlag': true } : + null + ); + return RegExp(pattern, flags || ''); + }, + 'valueOf': function() { // Note: `valueOf` is aliased as `toArray`. + return dataToArray(this.data); + } + }); + + proto.toArray = proto.valueOf; + + // Some AMD build optimizers, like r.js, check for specific condition patterns + // like the following: + if ( + typeof define == 'function' && + typeof define.amd == 'object' && + define.amd + ) { + define(function() { + return regenerate; + }); + } else if (freeExports && !freeExports.nodeType) { + if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+ + freeModule.exports = regenerate; + } else { // in Narwhal or RingoJS v0.7.0- + freeExports.regenerate = regenerate; + } + } else { // in Rhino or a web browser + root.regenerate = regenerate; + } + +}(this)); diff --git a/tools/ui/node_modules/regexp.prototype.flags/.editorconfig b/tools/ui/node_modules/regexp.prototype.flags/.editorconfig new file mode 100644 index 0000000000000000000000000000000000000000..eaa214161f5cdb409c32465fd822624c633a6bd8 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/.editorconfig @@ -0,0 +1,13 @@ +root = true + +[*] +indent_style = tab; +insert_final_newline = true; +quote_type = auto; +space_after_anonymous_functions = true; +space_after_control_statements = true; +spaces_around_operators = true; +trim_trailing_whitespace = true; +spaces_in_brackets = false; +end_of_line = lf; + diff --git a/tools/ui/node_modules/regexp.prototype.flags/.eslintrc b/tools/ui/node_modules/regexp.prototype.flags/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..fb009abaed247561dac416ce3e84805ff98a3b43 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/.eslintrc @@ -0,0 +1,20 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "eqeqeq": [2, "allow-null"], + "id-length": 0, + "no-invalid-this": "off", + }, + + "overrides": [ + { + "files": "test/**", + "rules": { + "max-lines-per-function": 0, + }, + }, + ], +} diff --git a/tools/ui/node_modules/regexp.prototype.flags/.nycrc b/tools/ui/node_modules/regexp.prototype.flags/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..bdd626ce91477abbdd489b79988baebadbd3c897 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/regexp.prototype.flags/CHANGELOG.md b/tools/ui/node_modules/regexp.prototype.flags/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..bf84c26b75881b696009502d2dbdf28c4e723cef --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/CHANGELOG.md @@ -0,0 +1,249 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.5.4](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.5.3...v1.5.4) - 2025-01-02 + +### Commits + +- [Refactor] use `get-proto` and `es-errors` [`6355772`](https://github.com/es-shims/RegExp.prototype.flags/commit/6355772344db0465e11c58e387f968de0cf4e4fa) +- [Deps] update `call-bind` [`c630183`](https://github.com/es-shims/RegExp.prototype.flags/commit/c6301838b07f3e71b3dc1d5b2cfa88f88b9f6a6d) +- [Dev Deps] update `object-inspect` [`c0201af`](https://github.com/es-shims/RegExp.prototype.flags/commit/c0201af97cb849947d5246fa7d9f9a8ea5bc5b36) + +## [v1.5.3](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.5.2...v1.5.3) - 2024-10-03 + +### Fixed + +- [Fix] avoid unnecessary polyfill [`#31`](https://github.com/es-shims/RegExp.prototype.flags/issues/31) + +### Commits + +- [Dev Deps] update `@es-shims/api`, `@ljharb/eslint-config`, `aud`, `object-inspect`, `tape` [`9e8bc20`](https://github.com/es-shims/RegExp.prototype.flags/commit/9e8bc20868a6366c08cfa9f37648573b8bcab449) +- [Dev Deps] update `@es-shims/api`, `auto-changelog`, `es-value-fixtures`, `tape` [`c32be8e`](https://github.com/es-shims/RegExp.prototype.flags/commit/c32be8e8bb8b6726376ba82d27a31087b4847444) +- [readme] fix typos [`195c32e`](https://github.com/es-shims/RegExp.prototype.flags/commit/195c32e7f48d09b12428442aaaa5a28a72d56287) +- [Deps] update `call-bind`, `set-function-name` [`207517f`](https://github.com/es-shims/RegExp.prototype.flags/commit/207517f62aa8f6a9c721c6d484c2c7f5a386864a) +- [Dev Deps] update `available-regexp-flags`, `tape` [`b3854f7`](https://github.com/es-shims/RegExp.prototype.flags/commit/b3854f70afa7a5da8c0f4cac40bb8ad8df71d297) +- [Tests] replace `aud` with `npm audit` [`d3ee951`](https://github.com/es-shims/RegExp.prototype.flags/commit/d3ee951c0760b3f9f01e5a953dfef92c8d6fcfb4) +- [Dev Deps] update `hasown` [`9e407c4`](https://github.com/es-shims/RegExp.prototype.flags/commit/9e407c41cd8db52b1fd602ae3117b3cd3e1beecc) +- [Dev Deps] add missing peer dep [`0199bfd`](https://github.com/es-shims/RegExp.prototype.flags/commit/0199bfd69dd140bdee743d6a874d758349aaaaaa) + +## [v1.5.2](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.5.1...v1.5.2) - 2024-02-11 + +### Commits + +- [Tests] increase coverage [`c692c88`](https://github.com/es-shims/RegExp.prototype.flags/commit/c692c88e073f6d17fc5b6b1c740ef1ecb433eb4b) +- [Dev Deps] use `hasown` instead of `has` [`fb5b350`](https://github.com/es-shims/RegExp.prototype.flags/commit/fb5b350122507e4bec68fb417a46f07d062caf77) +- [Dev Deps] update `aud`, `hasown`, `npmignore`, `tape` [`fd0ddd9`](https://github.com/es-shims/RegExp.prototype.flags/commit/fd0ddd9c837c0a8066de37a41eb4f83310f15a57) +- [Deps] update `call-bind`, `define-properties`, `set-function-name` [`ca53f66`](https://github.com/es-shims/RegExp.prototype.flags/commit/ca53f662549b2fbff61323a6d2aa9af15a6c836b) +- [Dev Deps] update `object-inspect`, `tape` [`4491680`](https://github.com/es-shims/RegExp.prototype.flags/commit/449168010d4d63a2cd854dcec9f37efacda19082) +- [Refactor] use `es-errors` [`1d03d22`](https://github.com/es-shims/RegExp.prototype.flags/commit/1d03d225327008aeb6b4b501a4720318d717621e) +- [Fix] properly check for a non-object receiver [`024d442`](https://github.com/es-shims/RegExp.prototype.flags/commit/024d4421edd8922f9acbac35afcfe69a8a3db6a9) +- [Deps] update `call-bind` [`f222ce0`](https://github.com/es-shims/RegExp.prototype.flags/commit/f222ce0925a7431d1d3dd113d803746f07e1175d) + +## [v1.5.1](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.5.0...v1.5.1) - 2023-09-12 + +### Commits + +- [Refactor] use `set-function-name` [`1384147`](https://github.com/es-shims/RegExp.prototype.flags/commit/13841474baf5700de8e3f65fae3670ad1b233483) +- [Dev Deps] update `@es-shims/api`, `@ljharb/eslint-config`, `aud`, `available-regexp-flags`, `tape` [`07bf9a2`](https://github.com/es-shims/RegExp.prototype.flags/commit/07bf9a2c354cc41379b01fe5c383233adaaccf0e) +- [Dev Deps] add missing `npmignore` dep [`8ca9dfe`](https://github.com/es-shims/RegExp.prototype.flags/commit/8ca9dfe4da31ef74ee48a4dcf62692eebb8f8fdd) + +## [v1.5.0](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.4.3...v1.5.0) - 2023-04-18 + +### Commits + +- [meta] use `npmignore` to autogenerate an npmignore file [`f7438ad`](https://github.com/es-shims/RegExp.prototype.flags/commit/f7438ad3728128b99daaeb1d3133a40d906d3621) +- [New] add `unicodeSets`/`v` flag [`f922170`](https://github.com/es-shims/RegExp.prototype.flags/commit/f92217039c9c86a61421ce69594e93a546721397) +- [Dev Deps] update `@es-shims/api`, `@ljharb/eslint-config`, `aud`, `available-regexp-flags`, `object-inspect`, `tape` [`1203078`](https://github.com/es-shims/RegExp.prototype.flags/commit/12030785e6beb1f06c406a4731714012d93867e2) +- [actions] update rebase action to use reusable workflow [`c562ea2`](https://github.com/es-shims/RegExp.prototype.flags/commit/c562ea20c27442ff30ce65091a313b5e49ae8515) +- [Dev Deps] update `aud`, `object-inspect`, `tape` [`f3ae811`](https://github.com/es-shims/RegExp.prototype.flags/commit/f3ae81109dd08b200dce8bd52c183bc44662c3b4) +- [Deps] update `define-properties`, `functions-have-names` [`2d0476e`](https://github.com/es-shims/RegExp.prototype.flags/commit/2d0476e5eba1e4a9b786f169f3be96c2f5a192b2) +- [Tests] use `for-each` instead of `foreach` [`d9f30da`](https://github.com/es-shims/RegExp.prototype.flags/commit/d9f30dab65ff0185a8688c6e62dc1fe650879cc0) +- [Deps] update `define-properties` [`81c1c20`](https://github.com/es-shims/RegExp.prototype.flags/commit/81c1c2012070c1f4480a9ab55bc0cff206152603) + +## [v1.4.3](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.4.2...v1.4.3) - 2022-04-14 + +### Commits + +- [Fix] when shimmed, name must be `get flags` [`fcefd00`](https://github.com/es-shims/RegExp.prototype.flags/commit/fcefd0039177e9cbcb2ed842d353131ace7a3377) + +## [v1.4.2](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.4.1...v1.4.2) - 2022-04-12 + +### Commits + +- [Fix] ensure `hasIndices` is patched properly, and getter order is correct [`a1af45a`](https://github.com/es-shims/RegExp.prototype.flags/commit/a1af45a8a6f7305b097b83f96ee9fc45abb3e733) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `auto-changelog`, `tape` [`24f5a0c`](https://github.com/es-shims/RegExp.prototype.flags/commit/24f5a0c84f2e7d263ae0e2008def870afd6d5a4f) + +## [v1.4.1](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.4.0...v1.4.1) - 2022-01-13 + +### Commits + +- [Fix] `polyfill`: do not throw in a descriptorless environment [`e2d24e7`](https://github.com/es-shims/RegExp.prototype.flags/commit/e2d24e707a44d958a0b6d3a114effb2f2b475337) + +## [v1.4.0](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.3.2...v1.4.0) - 2022-01-13 + +### Commits + +- [Tests] use `available-regexp-flags` [`95af246`](https://github.com/es-shims/RegExp.prototype.flags/commit/95af2463f1373282087528f8566e20ffae26c3db) +- [New] add `hasIndices`/`d` flag [`89959ca`](https://github.com/es-shims/RegExp.prototype.flags/commit/89959ca1128ea48dcd0ec1416355264425fa3bc5) + +## [v1.3.2](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.3.1...v1.3.2) - 2022-01-13 + +### Commits + +- [actions] reuse common workflows [`6665b5d`](https://github.com/es-shims/RegExp.prototype.flags/commit/6665b5db7c45ce6b987d08ebaf6d2767eec95b94) +- [actions] use `node/install` instead of `node/run`; use `codecov` action [`babce94`](https://github.com/es-shims/RegExp.prototype.flags/commit/babce94b5ca96e93e74e384c0a01295943677a3f) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `@es-shims/api`, `object-inspect`, `safe-publish-latest`, `tape` [`52132d9`](https://github.com/es-shims/RegExp.prototype.flags/commit/52132d9f3df904864d4cf3fd44892ee563aee524) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `@es-shims/api`, `aud`, `auto-changelog`, `object-inspect`, `tape` [`c16687c`](https://github.com/es-shims/RegExp.prototype.flags/commit/c16687c118d374d8997a8d885467507bf943b4bc) +- [actions] update codecov uploader [`0a3c904`](https://github.com/es-shims/RegExp.prototype.flags/commit/0a3c904a9fd1247b3b8e0fb6b451b3fbe97735bd) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `object-inspect`, `tape` [`3fce7f2`](https://github.com/es-shims/RegExp.prototype.flags/commit/3fce7f27c753440003675d03ae9a7ecfa6a74d30) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`75ca498`](https://github.com/es-shims/RegExp.prototype.flags/commit/75ca49889349fc42e51ea79b2ec7a1996fb3eb18) +- [actions] update workflows [`300f321`](https://github.com/es-shims/RegExp.prototype.flags/commit/300f321984526066656bec791f0bb3861b33cfbc) +- [meta] better `eccheck` command [`5f735ab`](https://github.com/es-shims/RegExp.prototype.flags/commit/5f735ab1b1c87dbd05c0096249160587f166cd51) +- [Dev Deps] update `eslint`, `tape` [`3059637`](https://github.com/es-shims/RegExp.prototype.flags/commit/3059637210eb5c9fa97160ec2f0aea1d1d724eb7) +- [actions] update workflows` [`dbd8ab4`](https://github.com/es-shims/RegExp.prototype.flags/commit/dbd8ab49fa2196dd74791107825c43e4481cdfd2) +- [meta] use `prepublishOnly` script for npm 7+ [`5cc8652`](https://github.com/es-shims/RegExp.prototype.flags/commit/5cc86524a41bf358b6701bcf46e480f0e3e470b4) +- [Fix] use polyfill, not implementation, in main export [`15ab4b8`](https://github.com/es-shims/RegExp.prototype.flags/commit/15ab4b85f3904e48664e26394dc12765ed666da4) +- [meta] remove `audit-level` config, which breaks npm 7 installs [`1cb98ae`](https://github.com/es-shims/RegExp.prototype.flags/commit/1cb98aed731e73d11df5ed3b853b371d35a69f5a) + +## [v1.3.1](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.3.0...v1.3.1) - 2021-01-15 + +### Commits + +- [Tests] run `nyc` on all tests; use `tape` runner; add full es-shims test suite [`047a1e8`](https://github.com/es-shims/RegExp.prototype.flags/commit/047a1e8ff250220254b0e9598d962a56c8ec3ffc) +- [Tests] migrate tests to Github Actions [`e4e391f`](https://github.com/es-shims/RegExp.prototype.flags/commit/e4e391fd3e6f057172994ad0c33ca128568c0b06) +- [meta] use `auto-changelog` for changelog [`afbcd06`](https://github.com/es-shims/RegExp.prototype.flags/commit/afbcd06402e97e975af797e2c1375e35e22e90f2) +- [actions] add Require Allow Edits workflow [`0db5d50`](https://github.com/es-shims/RegExp.prototype.flags/commit/0db5d50cdf59e3e5529024af4f8ce05829edc06d) +- [meta] do not publish github action workflow files [`53f2902`](https://github.com/es-shims/RegExp.prototype.flags/commit/53f29020e5a1f517e91b8cf226ed6bc97eadc090) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape`; add `aud` [`05f2a85`](https://github.com/es-shims/RegExp.prototype.flags/commit/05f2a851869069c7911176809028be8491465f86) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`2a197b8`](https://github.com/es-shims/RegExp.prototype.flags/commit/2a197b84916f094946c5cad56ef8e7bb7e8f12ac) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape`; add `safe-publish-latest` [`e40bd37`](https://github.com/es-shims/RegExp.prototype.flags/commit/e40bd37de9bb756672832a6c994652965d09b9ae) +- [Refactor] use `call-bind` instead of `es-abstract` [`e6eac90`](https://github.com/es-shims/RegExp.prototype.flags/commit/e6eac9052ebdb4bc28cb83b5d3017a4ed74fe3f1) +- [Deps] update `es-abstract` [`f198075`](https://github.com/es-shims/RegExp.prototype.flags/commit/f198075d6fc075e0d98967af98a512742e6e7e4f) +- [actions] switch Automatic Rebase workflow to `pull_request_target` event [`2d21727`](https://github.com/es-shims/RegExp.prototype.flags/commit/2d217275d78214b82c7f5cacca85ca2308df83f1) +- [Deps] update `es-abstract` [`7e7ddc6`](https://github.com/es-shims/RegExp.prototype.flags/commit/7e7ddc66174256f6688a857b09c9a02bafcf4866) + +## [v1.3.0](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.2.0...v1.3.0) - 2019-12-14 + +### Commits + +- [Tests] remove `jscs` [`4a09ab4`](https://github.com/es-shims/RegExp.prototype.flags/commit/4a09ab467f62065a1718b0dcc50f7818b5400ab6) +- [Tests] use shared travis-ci configs [`8afa6a9`](https://github.com/es-shims/RegExp.prototype.flags/commit/8afa6a99fd35c19fb49ba630fd17159a5da2a34e) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `covert`, `has`, `tape` [`13a9fc9`](https://github.com/es-shims/RegExp.prototype.flags/commit/13a9fc9d6bc2600681eb3f638668beccf80b843c) +- [Refactor] use `callBind` helper from `es-abstract` [`c3a3727`](https://github.com/es-shims/RegExp.prototype.flags/commit/c3a37276764d99c1e4f7e9467ad636fce8c92c58) +- [actions] add automatic rebasing / merge commit blocking [`51e3f93`](https://github.com/es-shims/RegExp.prototype.flags/commit/51e3f9366d15a07edaf532884948ce74b6827125) +- [Tests] use `npx aud` instead of `nsp` or `npm audit` with hoops [`7e1ee50`](https://github.com/es-shims/RegExp.prototype.flags/commit/7e1ee505df374867c2c04d500aa1c36265161b6f) +- [meta] add `funding` field [`c99cbec`](https://github.com/es-shims/RegExp.prototype.flags/commit/c99cbec1af9b0e0be42e82f164adacf2e1bdee16) +- [New] add `auto` entry point [`1e53e85`](https://github.com/es-shims/RegExp.prototype.flags/commit/1e53e854f663472e74dd0350e0c095df9c2b9c7b) +- [Tests] use `eclint` instead of `editorconfig-tools` [`8600bfe`](https://github.com/es-shims/RegExp.prototype.flags/commit/8600bfed42ab8d294463df482874c344fc079f82) +- [Deps] update `define-properties` [`ad221fa`](https://github.com/es-shims/RegExp.prototype.flags/commit/ad221fa2a26a9c2bc8d274b689cf7a626b58f4e9) + +## [v1.2.0](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.1.1...v1.2.0) - 2017-10-24 + +### Commits + +- [Tests] up to `node` `v8.8`, `v7.10`, `v6.11`, `v4.8`; improve matrix; use `nvm install-latest-npm` so new npm doesn’t break old node [`5a9653d`](https://github.com/es-shims/RegExp.prototype.flags/commit/5a9653d1904eb8ad8baffe43cd065b6f36013e5a) +- [Dev Deps] update `tape`, `jscs`, `nsp`, `eslint`, `@ljharb/eslint-config`; add `has` [`556de86`](https://github.com/es-shims/RegExp.prototype.flags/commit/556de8632bbe7a23279717f7d0b6ee841514fbe1) +- [Dev Deps] update `tape`, `jscs`, `nsp`, `eslint`, `@ljharb/eslint-config` [`726772c`](https://github.com/es-shims/RegExp.prototype.flags/commit/726772c054a499ab7680823c4bd8fa9b048d9420) +- [New] add support for `dotAll` regex flag. [`fcbd64f`](https://github.com/es-shims/RegExp.prototype.flags/commit/fcbd64f84fd974d98384bdb093bf25656eb72e8f) +- [Dev Deps] update `eslint`, `jscs`, `nsp`, `tape`, `@ljharb/eslint-config`, `@es-shims/api` [`0272934`](https://github.com/es-shims/RegExp.prototype.flags/commit/02729344addadc105b9c5e12d90cca85a75d16d6) +- [Dev Deps] update `jscs`, `nsp`, `eslint` [`e4cd264`](https://github.com/es-shims/RegExp.prototype.flags/commit/e4cd264f4afa33ff865325b04791de95696e3ae4) +- [Dev Deps] update `jscs`, `nsp`, `eslint`, `@es-shims/api` [`baf5169`](https://github.com/es-shims/RegExp.prototype.flags/commit/baf51698ac00b31b6a4a6d5646a183a409ad1118) +- [Dev Deps] update `tape`, `nsp`, `eslint`, `@ljharb/eslint-config` [`97cea15`](https://github.com/es-shims/RegExp.prototype.flags/commit/97cea152c20bb0e63e9c5111780f7b4af5d1a0e8) +- [Dev Deps] update `tape`, `discs`, `eslint`, `@ljharb/eslint-config` [`b6872f4`](https://github.com/es-shims/RegExp.prototype.flags/commit/b6872f44c833f6f7faf63881657208b6cd43ef49) +- [Dev Deps] update `tape`, `jscs`, `nsp`, `eslint`, `@ljharb/eslint-config` [`14702cc`](https://github.com/es-shims/RegExp.prototype.flags/commit/14702ccd050029d4e6ea2e59d0912e6bfc16ffc0) +- [Dev Deps] update `jscs`, `@es-shims/api` [`cd060a6`](https://github.com/es-shims/RegExp.prototype.flags/commit/cd060a650db019be5244e1c1b77a29f6d79c89db) +- [Tests] up to `node` `v6.2`, `v5.11` [`14638bd`](https://github.com/es-shims/RegExp.prototype.flags/commit/14638bdbd62d6b6a7c89efb8ec57a7815032b4bb) +- [Tests] up to `io.js` `v3.3`, `node` `v4.1` [`b0a5ffb`](https://github.com/es-shims/RegExp.prototype.flags/commit/b0a5ffb25a76783053652e0d7f835e354f9b29b6) +- [Tests] npm run silently [`35804d4`](https://github.com/es-shims/RegExp.prototype.flags/commit/35804d45dd7f57faab923aaab914e6390813e700) +- [Tests] up to `node` `v5.9`, `v4.4` [`e0fe80d`](https://github.com/es-shims/RegExp.prototype.flags/commit/e0fe80d96783820444d6dea1e6b5739032a50c1b) +- [Tests] up to `node` `v5.7`, `v4.3` [`9739c42`](https://github.com/es-shims/RegExp.prototype.flags/commit/9739c422523571cc439d73a9ecaf5dc2e2643bec) +- [Dev Deps] update `jscs` [`4aa1699`](https://github.com/es-shims/RegExp.prototype.flags/commit/4aa1699a0582b7739f14c6cd8d5ae1a4515bd604) +- [Dev Deps] update `tape`, `jscs`, `nsp`, `@ljharb/eslint-config` [`8bc5e6b`](https://github.com/es-shims/RegExp.prototype.flags/commit/8bc5e6ba5befc8f399e00f3c2d064519457fb57c) +- [Tests] fix npm upgrades on older nodes [`ae00bb9`](https://github.com/es-shims/RegExp.prototype.flags/commit/ae00bb9d979605f41fc598156b5c590923ac8184) +- Only apps should have lockfiles. [`6d14965`](https://github.com/es-shims/RegExp.prototype.flags/commit/6d1496550a962ea8525fb7b62dc4ac99d9513a6d) +- [Tests] use pretest/posttest for better organization [`0520cfd`](https://github.com/es-shims/RegExp.prototype.flags/commit/0520cfda23835fb5bff038a6e5cc530b0ce66985) +- [Tests] up to `node` `v5.5` [`810f62b`](https://github.com/es-shims/RegExp.prototype.flags/commit/810f62b6d2418e843b7c2c225841e9305dbc01ee) +- [Tests] on `node` `v5.3` [`f839662`](https://github.com/es-shims/RegExp.prototype.flags/commit/f839662887cbb1a5e472a9302185355b431c85c1) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config` [`78ecaa5`](https://github.com/es-shims/RegExp.prototype.flags/commit/78ecaa5b203a07f76505824f77ce1e5d60d8b0ca) +- [Tests] up to `node` `v5.2` [`c04d762`](https://github.com/es-shims/RegExp.prototype.flags/commit/c04d762a8c09ab544df14c14521f32dac3f67823) +- [Tests] up to `node` `v5.0` [`7c0d5b9`](https://github.com/es-shims/RegExp.prototype.flags/commit/7c0d5b944d9ba30f38227d0750109d582be254e2) +- [Tests] on `node` `v5.10` [`40ddafd`](https://github.com/es-shims/RegExp.prototype.flags/commit/40ddafd83e2e1c959ee8ba24cb296559f2545a0c) +- [Deps] update `define-properties` [`98ea89d`](https://github.com/es-shims/RegExp.prototype.flags/commit/98ea89dc9c41b81b84d4071105048687dab0660e) + +## [v1.1.1](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.1.0...v1.1.1) - 2015-08-16 + +### Commits + +- [Fix] cover the case where there is no descriptor on the prototype [`67014c3`](https://github.com/es-shims/RegExp.prototype.flags/commit/67014c35a93c76e28c4ab5cd3e5a54f7f40c2ddf) + +## [v1.1.0](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.0.1...v1.1.0) - 2015-08-16 + +### Commits + +- Update `jscs`, `eslint`; use my personal shared `eslint` config. [`37ca379`](https://github.com/es-shims/RegExp.prototype.flags/commit/37ca379bc72620fa6785b0a9ca791b160328c236) +- Update `eslint`, `tape`, `editorconfig-tools`, `nsp` [`cb92d6e`](https://github.com/es-shims/RegExp.prototype.flags/commit/cb92d6e8a8c1df5f00a226e11a78f38c6f7c3055) +- Implement the [es-shim API](es-shims/api). [`15eb821`](https://github.com/es-shims/RegExp.prototype.flags/commit/15eb821be2771e03a1341a08483513702118b45c) +- Refactoring to reduce complexity. [`aeb4785`](https://github.com/es-shims/RegExp.prototype.flags/commit/aeb47854f6b00355702104066c63f6eed38b5e81) +- Move implementation to `implementation.js` [`a698925`](https://github.com/es-shims/RegExp.prototype.flags/commit/a698925b4c1c78cd1ed4315b9deb5bb1707d5203) +- Update `eslint`, `jscs` [`277a4a1`](https://github.com/es-shims/RegExp.prototype.flags/commit/277a4a15e663eb823b63743b84645158b9bb9a43) +- Update `nsp`, `eslint` [`c9f3866`](https://github.com/es-shims/RegExp.prototype.flags/commit/c9f3866e25b52050f6bfe3fd0de8849de0271ea4) +- Update `tape`, `eslint` [`a08795b`](https://github.com/es-shims/RegExp.prototype.flags/commit/a08795b688b186fa5a2ec207358d81c16a07d30d) +- Make some things a bit more robust. [`450abb4`](https://github.com/es-shims/RegExp.prototype.flags/commit/450abb48974f10bfd2d9478e7ea1b9d87f004fb9) +- Update `eslint` [`25d898f`](https://github.com/es-shims/RegExp.prototype.flags/commit/25d898f62719b26fea5f9245be141103d4ec58cd) +- Test on latest two `io.js` versions. [`2e17ca3`](https://github.com/es-shims/RegExp.prototype.flags/commit/2e17ca304e12fb5071a091706a4d559b3eac968a) +- All grade A-supported `node`/`iojs` versions now ship with an `npm` that understands `^`. [`4a2a548`](https://github.com/es-shims/RegExp.prototype.flags/commit/4a2a5480c50f30814000684462a8a3b44c87ae2e) +- Update `eslint` [`64df4e0`](https://github.com/es-shims/RegExp.prototype.flags/commit/64df4e0a2d0e2901b57652e30913db797dc0829b) +- Update `eslint` [`ac05ae5`](https://github.com/es-shims/RegExp.prototype.flags/commit/ac05ae509a4a70d107820a749ea6f02784fc41eb) +- Clean up `supportsDescriptors` check. [`e44d0de`](https://github.com/es-shims/RegExp.prototype.flags/commit/e44d0dec9c8415ff9a911b8806e1d245d6919a11) +- [Dev Deps] Update `jscs` [`8741758`](https://github.com/es-shims/RegExp.prototype.flags/commit/87417588f52f1176fc37d7c32221aa85f749aa34) +- Update `tape`, `jscs`, `nsp`, `eslint` [`db1f658`](https://github.com/es-shims/RegExp.prototype.flags/commit/db1f6584b18cc035ef3b5aec556f54e0ee8c639d) +- Test on `io.js` `v2.3` [`18c948f`](https://github.com/es-shims/RegExp.prototype.flags/commit/18c948f033c87ab2657a0395052cbec531c40900) +- Run `travis-ci` tests on `iojs` and `node` v0.12; speed up builds; allow 0.8 failures. [`c37e79f`](https://github.com/es-shims/RegExp.prototype.flags/commit/c37e79f380d87a226a6cdaa5f09f832f5dc21b7d) +- Update `tape`, `jscs`, `eslint` [`4b652bf`](https://github.com/es-shims/RegExp.prototype.flags/commit/4b652bf5f2f0e36a15227d0b4048de91ee6c4433) +- [Dev Deps] Update `tape`, `eslint` [`29d4ac0`](https://github.com/es-shims/RegExp.prototype.flags/commit/29d4ac0bea16c6a9f611cb15baccd30449f30a91) +- Test up to `io.js` `v2.1` [`9f9e342`](https://github.com/es-shims/RegExp.prototype.flags/commit/9f9e34295ced1b288dea08e0a66dffd2bc03ff8b) +- Update `covert`, `jscs` [`c98f3b4`](https://github.com/es-shims/RegExp.prototype.flags/commit/c98f3b47f01f317e8a589486dfaee482c66b8b64) +- Update `jscs` [`9e5e220`](https://github.com/es-shims/RegExp.prototype.flags/commit/9e5e220be6ec5d5b9b658235287e35bded580b06) +- [Dev Deps] update `tape` [`cdd3af2`](https://github.com/es-shims/RegExp.prototype.flags/commit/cdd3af21507b01aa524f8b87f158dfc8a8153c85) +- [Dev Deps] update `tape` [`d42d0bf`](https://github.com/es-shims/RegExp.prototype.flags/commit/d42d0bf28f8da2cb47fff49283a07a693f8cb626) +- Switch from vb.teelaun.ch to versionbadg.es for the npm version badge SVG. [`a5e7453`](https://github.com/es-shims/RegExp.prototype.flags/commit/a5e745375c01e9f90ff632c55a5b44b6ada38217) +- Update `tape` [`2a675ec`](https://github.com/es-shims/RegExp.prototype.flags/commit/2a675ec707a9d89aea403d0b9a723ea531e50c2d) +- Test on `io.js` `v2.5` [`448cbdb`](https://github.com/es-shims/RegExp.prototype.flags/commit/448cbdb7df47e52677daea4e0c41e892ad8770e4) +- Test on `io.js` `v2.4` [`948e511`](https://github.com/es-shims/RegExp.prototype.flags/commit/948e51129c01147ffe4dedc3a7d4980128d0cf73) +- Test on `io.js` `v2.2` [`4793278`](https://github.com/es-shims/RegExp.prototype.flags/commit/4793278f5aca187e36b42b08fc1388d8021400e2) +- Update `eslint` [`0f463da`](https://github.com/es-shims/RegExp.prototype.flags/commit/0f463daa14a193ed94b16c46832074d63e861c91) +- Update `eslint` [`5a16967`](https://github.com/es-shims/RegExp.prototype.flags/commit/5a16967db71bb8a24c81a27ee366f0b02b663e34) +- Test on `io.js` `v3.0` [`7ba8706`](https://github.com/es-shims/RegExp.prototype.flags/commit/7ba87064bc8520d34a9560bea8e366d70c93dbbb) +- Test on `iojs-v1.2` [`b521e09`](https://github.com/es-shims/RegExp.prototype.flags/commit/b521e099b7de48cfbdd6860265eb5e972d2859a5) + +## [v1.0.1](https://github.com/es-shims/RegExp.prototype.flags/compare/v1.0.0...v1.0.1) - 2014-12-13 + +### Merged + +- Match the spec properly: throw when not an object; make getter generic. [`#3`](https://github.com/es-shims/RegExp.prototype.flags/pull/3) + +### Fixed + +- Match the spec properly [`#1`](https://github.com/es-shims/RegExp.prototype.flags/issues/1) + +### Commits + +- Speed up the “is object” check in case of `null` or `undefined` [`77137f9`](https://github.com/es-shims/RegExp.prototype.flags/commit/77137f99449c9b6583cdfda295a00b832dfd45f3) + +## v1.0.0 - 2014-12-10 + +### Commits + +- Adding dotfiles [`313812e`](https://github.com/es-shims/RegExp.prototype.flags/commit/313812e1d8ff42a13dbc8689f2e719324c46c9ca) +- Tests [`625a042`](https://github.com/es-shims/RegExp.prototype.flags/commit/625a042220a3152b49608fb6f187f67bff02b6fb) +- Add package.json [`8b98257`](https://github.com/es-shims/RegExp.prototype.flags/commit/8b98257f900d0a73c8eb3805b9b01999e05e880a) +- Adding the README [`884798b`](https://github.com/es-shims/RegExp.prototype.flags/commit/884798b710d5a85bc6d9a6879f509766e2e57c0e) +- Implementation. [`4186cc9`](https://github.com/es-shims/RegExp.prototype.flags/commit/4186cc9d9a7533f78d88be976f0a8a2757604fc5) +- Adding LICENSE and CHANGELOG [`f87fa81`](https://github.com/es-shims/RegExp.prototype.flags/commit/f87fa8126cc6c39747fbe0dc6cb40ca0ff77fbbc) +- Fixing README URLs [`b821703`](https://github.com/es-shims/RegExp.prototype.flags/commit/b821703d5e5b01ee4f526f15c8e525645cf95ef7) +- Clean up dependencies; update `tape`, `jscs`, `nsp` [`0e13fc1`](https://github.com/es-shims/RegExp.prototype.flags/commit/0e13fc12df09f3a7ac30116ef13bba820c220730) +- Initial commit. [`8a9e35e`](https://github.com/es-shims/RegExp.prototype.flags/commit/8a9e35e15f65c9640e64ee14fab190a60993efaa) diff --git a/tools/ui/node_modules/regexp.prototype.flags/LICENSE b/tools/ui/node_modules/regexp.prototype.flags/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..e5956a86be2f2b56369cafe1b348612dc74dca80 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (C) 2014 Jordan Harband + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + diff --git a/tools/ui/node_modules/regexp.prototype.flags/README.md b/tools/ui/node_modules/regexp.prototype.flags/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ca5f28252b70f3f9a93fefe51a9afe67049dca5c --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/README.md @@ -0,0 +1,55 @@ +RegExp.prototype.flags [![Version Badge][npm-version-svg]][package-url] + +[![Build Status][travis-svg]][travis-url] +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +[![browser support][testling-svg]][testling-url] + +An ES6 spec-compliant `RegExp.prototype.flags` shim. Invoke its "shim" method to shim RegExp.prototype.flags if it is unavailable. +*Note*: `RegExp#flags` requires a true ES5 environment - specifically, one with ES5 getters. + +This package implements the [es-shim API](https://github.com/es-shims/api) interface. It works in an ES5-supported environment and complies with the [spec](http://www.ecma-international.org/ecma-262/6.0/#sec-get-regexp.prototype.flags). + +Most common usage: +```js +var flags = require('regexp.prototype.flags'); +var assert = require('assert'); + +assert(flags(/a/) === ''); +assert(flags(new RegExp('a')) === ''); +assert(flags(/a/mig) === 'gim'); +assert(flags(new RegExp('a', 'mig')) === 'gim'); + +if (!RegExp.prototype.flags) { + flags.shim(); +} + +assert(flags(/a/) === /a/.flags); +assert(flags(new RegExp('a')) === new RegExp('a').flags); +assert(flags(/a/mig) === /a/mig.flags); +assert(flags(new RegExp('a', 'mig')) === new RegExp('a', 'mig').flags); +``` + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +[package-url]: https://npmjs.com/package/regexp.prototype.flags +[npm-version-svg]: http://versionbadg.es/es-shims/RegExp.prototype.flags.svg +[travis-svg]: https://travis-ci.org/es-shims/RegExp.prototype.flags.svg +[travis-url]: https://travis-ci.org/es-shims/RegExp.prototype.flags +[deps-svg]: https://david-dm.org/es-shims/RegExp.prototype.flags.svg +[deps-url]: https://david-dm.org/es-shims/RegExp.prototype.flags +[dev-deps-svg]: https://david-dm.org/es-shims/RegExp.prototype.flags/dev-status.svg +[dev-deps-url]: https://david-dm.org/es-shims/RegExp.prototype.flags#info=devDependencies +[testling-svg]: https://ci.testling.com/es-shims/RegExp.prototype.flags.png +[testling-url]: https://ci.testling.com/es-shims/RegExp.prototype.flags +[npm-badge-png]: https://nodei.co/npm/regexp.prototype.flags.png?downloads=true&stars=true +[license-image]: http://img.shields.io/npm/l/regexp.prototype.flags.svg +[license-url]: LICENSE +[downloads-image]: http://img.shields.io/npm/dm/regexp.prototype.flags.svg +[downloads-url]: http://npm-stat.com/charts.html?package=regexp.prototype.flags diff --git a/tools/ui/node_modules/regexp.prototype.flags/auto.js b/tools/ui/node_modules/regexp.prototype.flags/auto.js new file mode 100644 index 0000000000000000000000000000000000000000..8ebf606cb02ff3a8c6ef786afa37d21a19254f46 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/auto.js @@ -0,0 +1,3 @@ +'use strict'; + +require('./shim')(); diff --git a/tools/ui/node_modules/regexp.prototype.flags/implementation.js b/tools/ui/node_modules/regexp.prototype.flags/implementation.js new file mode 100644 index 0000000000000000000000000000000000000000..4005503b2fb24041918fc5f1d1659b8e39ea5ed9 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/implementation.js @@ -0,0 +1,39 @@ +'use strict'; + +var setFunctionName = require('set-function-name'); +var $TypeError = require('es-errors/type'); + +var $Object = Object; + +module.exports = setFunctionName(function flags() { + if (this == null || this !== $Object(this)) { + throw new $TypeError('RegExp.prototype.flags getter called on non-object'); + } + var result = ''; + if (this.hasIndices) { + result += 'd'; + } + if (this.global) { + result += 'g'; + } + if (this.ignoreCase) { + result += 'i'; + } + if (this.multiline) { + result += 'm'; + } + if (this.dotAll) { + result += 's'; + } + if (this.unicode) { + result += 'u'; + } + if (this.unicodeSets) { + result += 'v'; + } + if (this.sticky) { + result += 'y'; + } + return result; +}, 'get flags', true); + diff --git a/tools/ui/node_modules/regexp.prototype.flags/index.js b/tools/ui/node_modules/regexp.prototype.flags/index.js new file mode 100644 index 0000000000000000000000000000000000000000..d6054c766d0860ff25a144addcba6125d25dea41 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/index.js @@ -0,0 +1,18 @@ +'use strict'; + +var define = require('define-properties'); +var callBind = require('call-bind'); + +var implementation = require('./implementation'); +var getPolyfill = require('./polyfill'); +var shim = require('./shim'); + +var flagsBound = callBind(getPolyfill()); + +define(flagsBound, { + getPolyfill: getPolyfill, + implementation: implementation, + shim: shim +}); + +module.exports = flagsBound; diff --git a/tools/ui/node_modules/regexp.prototype.flags/package.json b/tools/ui/node_modules/regexp.prototype.flags/package.json new file mode 100644 index 0000000000000000000000000000000000000000..51b5df7f160d3aef829dc9b07776080098adbdb6 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/package.json @@ -0,0 +1,105 @@ +{ + "name": "regexp.prototype.flags", + "version": "1.5.4", + "author": "Jordan Harband ", + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "description": "ES6 spec-compliant RegExp.prototype.flags shim.", + "license": "MIT", + "main": "index.js", + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prepublishOnly": "safe-publish-latest", + "pretest": "npm run lint", + "test": "npm run tests-only", + "posttest": "npx npm@'>=10.2' audit --production", + "tests-only": "nyc tape 'test/**/*.js'", + "prelint": "eclint check $(git ls-files | xargs find 2> /dev/null | grep -vE 'node_modules|\\.git')", + "lint": "eslint --ext=js,mjs .", + "postlint": "evalmd README.md && es-shim-api --bound", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git://github.com/es-shims/RegExp.prototype.flags.git" + }, + "keywords": [ + "RegExp.prototype.flags", + "regex", + "regular expression", + "ES6", + "shim", + "flag", + "flags", + "regexp", + "RegExp#flags", + "polyfill", + "es-shim API" + ], + "dependencies": { + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-errors": "^1.3.0", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "set-function-name": "^2.0.2" + }, + "devDependencies": { + "@es-shims/api": "^2.5.1", + "@ljharb/eslint-config": "^21.1.1", + "auto-changelog": "^2.5.0", + "available-regexp-flags": "^1.0.4", + "eclint": "^2.8.1", + "encoding": "^0.1.13", + "es-value-fixtures": "^1.5.0", + "eslint": "=8.8.0", + "evalmd": "^0.0.19", + "for-each": "^0.3.3", + "functions-have-names": "^1.2.3", + "has-strict-mode": "^1.0.1", + "hasown": "^2.0.2", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "object-inspect": "^1.13.3", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0" + }, + "testling": { + "files": "test/index.js", + "browsers": [ + "iexplore/9.0..latest", + "firefox/4.0..6.0", + "firefox/15.0..latest", + "firefox/nightly", + "chrome/4.0..10.0", + "chrome/20.0..latest", + "chrome/canary", + "opera/11.6..latest", + "opera/next", + "safari/5.0..latest", + "ipad/6.0..latest", + "iphone/6.0..latest", + "android-browser/4.2" + ] + }, + "engines": { + "node": ">= 0.4" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + } +} diff --git a/tools/ui/node_modules/regexp.prototype.flags/polyfill.js b/tools/ui/node_modules/regexp.prototype.flags/polyfill.js new file mode 100644 index 0000000000000000000000000000000000000000..8c78882fa272362e4863929c6b18b942430121cd --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/polyfill.js @@ -0,0 +1,39 @@ +'use strict'; + +var implementation = require('./implementation'); + +var supportsDescriptors = require('define-properties').supportsDescriptors; +var $gOPD = Object.getOwnPropertyDescriptor; + +module.exports = function getPolyfill() { + if (supportsDescriptors && (/a/mig).flags === 'gim') { + var descriptor = $gOPD(RegExp.prototype, 'flags'); + if ( + descriptor + && typeof descriptor.get === 'function' + && 'dotAll' in RegExp.prototype + && 'hasIndices' in RegExp.prototype + ) { + /* eslint getter-return: 0 */ + var calls = ''; + var o = {}; + Object.defineProperty(o, 'hasIndices', { + get: function () { + calls += 'd'; + } + }); + Object.defineProperty(o, 'sticky', { + get: function () { + calls += 'y'; + } + }); + + descriptor.get.call(o); + + if (calls === 'dy') { + return descriptor.get; + } + } + } + return implementation; +}; diff --git a/tools/ui/node_modules/regexp.prototype.flags/shim.js b/tools/ui/node_modules/regexp.prototype.flags/shim.js new file mode 100644 index 0000000000000000000000000000000000000000..9d22c8bb8f10006d419143434a4c40500a36a5f9 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/shim.js @@ -0,0 +1,26 @@ +'use strict'; + +var supportsDescriptors = require('define-properties').supportsDescriptors; +var getPolyfill = require('./polyfill'); +var gOPD = require('gopd'); +var defineProperty = Object.defineProperty; +var $TypeError = require('es-errors'); +var getProto = require('get-proto'); +var regex = /a/; + +module.exports = function shimFlags() { + if (!supportsDescriptors || !getProto) { + throw new $TypeError('RegExp.prototype.flags requires a true ES5 environment that supports property descriptors'); + } + var polyfill = getPolyfill(); + var proto = getProto(regex); + var descriptor = gOPD(proto, 'flags'); + if (!descriptor || descriptor.get !== polyfill) { + defineProperty(proto, 'flags', { + configurable: true, + enumerable: false, + get: polyfill + }); + } + return polyfill; +}; diff --git a/tools/ui/node_modules/regexp.prototype.flags/test/builtin.js b/tools/ui/node_modules/regexp.prototype.flags/test/builtin.js new file mode 100644 index 0000000000000000000000000000000000000000..ef3dac7005add570006c5d70fc0d8453cabfe2b2 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/test/builtin.js @@ -0,0 +1,46 @@ +'use strict'; + +var test = require('tape'); +var defineProperties = require('define-properties'); +var callBind = require('call-bind'); + +var isEnumerable = Object.prototype.propertyIsEnumerable; +var functionsHaveNames = require('functions-have-names')(); +var functionsHaveConfigurableNames = require('functions-have-names').functionsHaveConfigurableNames(); +var hasStrictMode = require('has-strict-mode')(); + +var runTests = require('./tests'); + +test('builtin', function (t) { + var descriptor = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags'); + + t.equal(descriptor.get.length, 0, 'RegExp#flags getter has a length of 0'); + + t.test('Function name', { skip: !functionsHaveNames }, function (st) { + st.equal(descriptor.get.name, functionsHaveConfigurableNames ? 'get flags' : 'flags', 'RegExp#flags getter has name "get flags" (or "flags" if function names are not configurable)'); + st.end(); + }); + + t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) { + et.equal(false, isEnumerable.call(RegExp.prototype, 'flags'), 'RegExp#flags is not enumerable'); + et.end(); + }); + + t.test('bad array/this value', { skip: !hasStrictMode }, function (st) { + st['throws'](function () { return descriptor.get.call(undefined); }, TypeError, 'undefined is not an object'); + st['throws'](function () { return descriptor.get.call(null); }, TypeError, 'null is not an object'); + st.end(); + }); + + t.test('has the correct descriptor', function (st) { + st.equal(descriptor.configurable, true); + st.equal(descriptor.enumerable, false); + st.equal(typeof descriptor.get, 'function'); + st.equal(descriptor.set, undefined); + st.end(); + }); + + runTests(callBind(descriptor.get), t); + + t.end(); +}); diff --git a/tools/ui/node_modules/regexp.prototype.flags/test/implementation.js b/tools/ui/node_modules/regexp.prototype.flags/test/implementation.js new file mode 100644 index 0000000000000000000000000000000000000000..1e3a7141659f21e408ae34265527fd9e6073e4c9 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/test/implementation.js @@ -0,0 +1,20 @@ +'use strict'; + +var flags = require('../implementation'); +var callBind = require('call-bind'); +var test = require('tape'); +var hasStrictMode = require('has-strict-mode')(); +var runTests = require('./tests'); + +test('as a function', function (t) { + t.test('bad array/this value', { skip: !hasStrictMode }, function (st) { + /* eslint no-useless-call: 0 */ + st['throws'](function () { flags.call(undefined); }, TypeError, 'undefined is not an object'); + st['throws'](function () { flags.call(null); }, TypeError, 'null is not an object'); + st.end(); + }); + + runTests(callBind(flags), t); + + t.end(); +}); diff --git a/tools/ui/node_modules/regexp.prototype.flags/test/index.js b/tools/ui/node_modules/regexp.prototype.flags/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..10d10713361ad6fa12fba5f665948e26f36e27f3 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/test/index.js @@ -0,0 +1,17 @@ +'use strict'; + +var flags = require('../'); +var test = require('tape'); +var runTests = require('./tests'); + +test('as a function', function (t) { + t.test('bad array/this value', function (st) { + st['throws'](function () { flags(undefined); }, TypeError, 'undefined is not an object'); + st['throws'](function () { flags(null); }, TypeError, 'null is not an object'); + st.end(); + }); + + runTests(flags, t); + + t.end(); +}); diff --git a/tools/ui/node_modules/regexp.prototype.flags/test/shimmed.js b/tools/ui/node_modules/regexp.prototype.flags/test/shimmed.js new file mode 100644 index 0000000000000000000000000000000000000000..059e0e17de6ec076827ed20a007ca9832b462a37 --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/test/shimmed.js @@ -0,0 +1,48 @@ +'use strict'; + +require('../auto'); + +var test = require('tape'); +var defineProperties = require('define-properties'); +var callBind = require('call-bind'); + +var isEnumerable = Object.prototype.propertyIsEnumerable; +var functionsHaveNames = require('functions-have-names')(); +var functionsHaveConfigurableNames = require('functions-have-names').functionsHaveConfigurableNames(); +var hasStrictMode = require('has-strict-mode')(); + +var runTests = require('./tests'); + +test('shimmed', function (t) { + var descriptor = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags'); + + t.equal(descriptor.get.length, 0, 'RegExp#flags getter has a length of 0'); + + t.test('Function name', { skip: !functionsHaveNames }, function (st) { + st.equal(descriptor.get.name, functionsHaveConfigurableNames ? 'get flags' : 'flags', 'RegExp#flags getter has name "get flags" (or "flags" if function names are not configurable)'); + st.end(); + }); + + t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) { + et.equal(false, isEnumerable.call(RegExp.prototype, 'flags'), 'RegExp#flags is not enumerable'); + et.end(); + }); + + t.test('bad array/this value', { skip: !hasStrictMode }, function (st) { + st['throws'](function () { return descriptor.get.call(undefined); }, TypeError, 'undefined is not an object'); + st['throws'](function () { return descriptor.get.call(null); }, TypeError, 'null is not an object'); + st.end(); + }); + + t.test('has the correct descriptor', function (st) { + st.equal(descriptor.configurable, true); + st.equal(descriptor.enumerable, false); + st.equal(typeof descriptor.get, 'function'); + st.equal(descriptor.set, undefined); + st.end(); + }); + + runTests(callBind(descriptor.get), t); + + t.end(); +}); diff --git a/tools/ui/node_modules/regexp.prototype.flags/test/tests.js b/tools/ui/node_modules/regexp.prototype.flags/test/tests.js new file mode 100644 index 0000000000000000000000000000000000000000..fbe41941c53195b3831e1a43a76cf9703517922c --- /dev/null +++ b/tools/ui/node_modules/regexp.prototype.flags/test/tests.js @@ -0,0 +1,143 @@ +'use strict'; + +var hasOwn = require('hasown'); +var inspect = require('object-inspect'); +var supportsDescriptors = require('define-properties').supportsDescriptors; +var v = require('es-value-fixtures'); + +var forEach = require('for-each'); +var availableFlags = require('available-regexp-flags'); +var regexProperties = require('available-regexp-flags/properties'); + +var sortedFlags = availableFlags.slice().sort(function (a, b) { return a.localeCompare(b); }).join(''); + +var getRegexLiteral = function (stringRegex) { + try { + // eslint-disable-next-line no-new-func + return Function('return ' + stringRegex + ';')(); + } catch (e) { /**/ } + return null; +}; + +module.exports = function runTests(flags, t) { + forEach(v.primitives, function (nonObject) { + t['throws']( + function () { flags(nonObject); }, + TypeError, + 'throws when called with a non-object receiver: ' + inspect(nonObject) + ); + }); + + t.equal(flags(/a/g), 'g', 'flags(/a/g) !== "g"'); + t.equal(flags(/a/gmi), 'gim', 'flags(/a/gmi) !== "gim"'); + t.equal(flags(new RegExp('a', 'gmi')), 'gim', 'flags(new RegExp("a", "gmi")) !== "gim"'); + t.equal(flags(/a/), '', 'flags(/a/) !== ""'); + t.equal(flags(new RegExp('a')), '', 'flags(new RegExp("a")) !== ""'); + + forEach(availableFlags, function (flag) { + var property = regexProperties[flag]; + t.test(property + ' flag', function (st) { + st.equal(flags(getRegexLiteral('/a/' + flag)), flag, 'flags(/a/' + flag + ') !== ' + inspect(flag)); + st.equal(flags(new RegExp('a', flag)), flag, 'flags(new RegExp("a", ' + inspect(flag) + ')) !== ' + inspect(flag)); + st.end(); + }); + }); + + t.test('sorting', function (st) { + st.equal(flags(/a/gim), 'gim', 'flags(/a/gim) !== "gim"'); + st.equal(flags(/a/mig), 'gim', 'flags(/a/mig) !== "gim"'); + st.equal(flags(/a/mgi), 'gim', 'flags(/a/mgi) !== "gim"'); + if (hasOwn(RegExp.prototype, 'sticky')) { + st.equal(flags(getRegexLiteral('/a/gyim')), 'gimy', 'flags(/a/gyim) !== "gimy"'); + } + if (hasOwn(RegExp.prototype, 'unicode')) { + st.equal(flags(getRegexLiteral('/a/ugmi')), 'gimu', 'flags(/a/ugmi) !== "gimu"'); + } + if (hasOwn(RegExp.prototype, 'dotAll')) { + st.equal(flags(getRegexLiteral('/a/sgmi')), 'gims', 'flags(/a/sgmi) !== "gims"'); + } + + var randomFlags = availableFlags.slice().sort(function () { return Math.random() > 0.5 ? 1 : -1; }).join('').replace('v', ''); + st.equal( + flags(getRegexLiteral('/a/' + randomFlags)), + sortedFlags.replace('v', ''), + 'random: flags(/a/' + randomFlags + ') === ' + inspect(sortedFlags) + ); + + st.end(); + }); + + t.test('basic examples', function (st) { + st.equal(flags(/a/g), 'g', '(/a/g).flags !== "g"'); + st.equal(flags(/a/gmi), 'gim', '(/a/gmi).flags !== "gim"'); + st.equal(flags(new RegExp('a', 'gmi')), 'gim', 'new RegExp("a", "gmi").flags !== "gim"'); + st.equal(flags(/a/), '', '(/a/).flags !== ""'); + st.equal(flags(new RegExp('a')), '', 'new RegExp("a").flags !== ""'); + + st.end(); + }); + + t.test('generic flags', function (st) { + st.equal(flags({}), ''); + st.equal(flags({ ignoreCase: true }), 'i'); + st.equal(flags({ dotAll: 1, global: 0, sticky: 1, unicode: 1 }), 'suy'); + st.equal(flags({ __proto__: { multiline: true } }), 'm'); + + var obj = {}; + forEach(availableFlags, function (flag) { + if (flag !== 'v') { + obj[regexProperties[flag]] = true; + } + }); + st.equal(flags(obj), sortedFlags.replace('v', ''), 'an object with every available flag: ' + sortedFlags); + + st.end(); + }); + + t.test('getters', { skip: !supportsDescriptors }, function (st) { + /* eslint getter-return: 0 */ + var calls = ''; + var re = {}; + Object.defineProperty(re, 'hasIndices', { + get: function () { + calls += 'd'; + } + }); + Object.defineProperty(re, 'global', { + get: function () { + calls += 'g'; + } + }); + Object.defineProperty(re, 'ignoreCase', { + get: function () { + calls += 'i'; + } + }); + Object.defineProperty(re, 'multiline', { + get: function () { + calls += 'm'; + } + }); + Object.defineProperty(re, 'dotAll', { + get: function () { + calls += 's'; + } + }); + Object.defineProperty(re, 'unicode', { + get: function () { + calls += 'u'; + } + }); + Object.defineProperty(re, 'sticky', { + get: function () { + calls += 'y'; + } + }); + + flags(re); + + st.equal(calls, 'dgimsuy', 'getters are called in expected order'); + + st.end(); + }); +}; diff --git a/tools/ui/node_modules/regexpu-core/LICENSE-MIT.txt b/tools/ui/node_modules/regexpu-core/LICENSE-MIT.txt new file mode 100644 index 0000000000000000000000000000000000000000..a41e0a7ef970ecdd83d82cd99bda97b22077bc62 --- /dev/null +++ b/tools/ui/node_modules/regexpu-core/LICENSE-MIT.txt @@ -0,0 +1,20 @@ +Copyright Mathias Bynens + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/regexpu-core/README.md b/tools/ui/node_modules/regexpu-core/README.md new file mode 100644 index 0000000000000000000000000000000000000000..fa661d824bf7de263edd946c42b1592efca86f3e --- /dev/null +++ b/tools/ui/node_modules/regexpu-core/README.md @@ -0,0 +1,226 @@ +# regexpu-core [![Build status](https://github.com/mathiasbynens/regexpu-core/workflows/run-checks/badge.svg)](https://github.com/mathiasbynens/regexpu-core/actions?query=workflow%3Arun-checks) [![regexpu-core on npm](https://img.shields.io/npm/v/regexpu-core)](https://www.npmjs.com/package/regexpu-core) + +_regexpu_ is a source code transpiler that enables the use of ES2015 Unicode regular expressions in JavaScript-of-today (ES5). + +_regexpu-core_ contains _regexpu_’s core functionality, i.e. `rewritePattern(pattern, flag)`, which enables rewriting regular expressions that make use of [the ES2015 `u` flag](https://mathiasbynens.be/notes/es6-unicode-regex) into equivalent ES5-compatible regular expression patterns. + +## Installation + +To use _regexpu-core_ programmatically, install it as a dependency via [npm](https://www.npmjs.com/): + +```bash +npm install regexpu-core --save +``` + +Then, `require` it: + +```js +const rewritePattern = require('regexpu-core'); +``` + +## API + +This module exports a single function named `rewritePattern`. + +### `rewritePattern(pattern, flags, options)` + +This function takes a string that represents a regular expression pattern as well as a string representing its flags, and returns an ES5-compatible version of the pattern. + +```js +rewritePattern('foo.bar', 'u', { unicodeFlag: "transform" }); +// → 'foo(?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uDC00-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF])bar' + +rewritePattern('[\\u{1D306}-\\u{1D308}a-z]', 'u', { unicodeFlag: "transform" }); +// → '(?:[a-z]|\\uD834[\\uDF06-\\uDF08])' + +rewritePattern('[\\u{1D306}-\\u{1D308}a-z]', 'ui', { unicodeFlag: "transform" }); +// → '(?:[a-z\\u017F\\u212A]|\\uD834[\\uDF06-\\uDF08])' +``` + +_regexpu-core_ can rewrite non-ES6 regular expressions too, which is useful to demonstrate how their behavior changes once the `u` and `i` flags are added: + +```js +// In ES5, the dot operator only matches BMP symbols: +rewritePattern('foo.bar', '', { unicodeFlag: "transform" }); +// → 'foo(?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uFFFF])bar' + +// But with the ES2015 `u` flag, it matches astral symbols too: +rewritePattern('foo.bar', 'u', { unicodeFlag: "transform" }); +// → 'foo(?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uDC00-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF])bar' +``` + +The optional `options` argument recognizes the following properties: + +#### Stable regular expression features + +These options can be set to `false` or `'transform'`. When using `'transform'`, the corresponding features are compiled to older syntax that can run in older browsers. When using `false` (the default), they are not compiled and they can be relied upon to compile more modern features. + +- `unicodeFlag` - The `u` flag, enabling support for Unicode code point escapes in the form `\u{...}`. + + ```js + rewritePattern('\\u{ab}', '', { + unicodeFlag: 'transform' + }); + // → '\\u{ab}' + + rewritePattern('\\u{ab}', 'u', { + unicodeFlag: 'transform' + }); + // → '\\xAB' + ``` + +- `dotAllFlag` - The [`s` (`dotAll`) flag](https://github.com/mathiasbynens/es-regexp-dotall-flag). + + ```js + rewritePattern('.', '', { + dotAllFlag: 'transform' + }); + // → '[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uFFFF]' + + rewritePattern('.', 's', { + dotAllFlag: 'transform' + }); + // → '[\\0-\\uFFFF]' + + rewritePattern('.', 'su', { + dotAllFlag: 'transform' + }); + // → '(?:[\\0-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])' + ``` + +- `unicodePropertyEscapes` - [Unicode property escapes](property-escapes.md). + + By default they are compiled to Unicode code point escapes of the form `\u{...}`. If the `unicodeFlag` option is set to `'transform'` they often result in larger output, although there are cases (such as `\p{Lu}`) where it actually _decreases_ the output size. + + ```js + rewritePattern('\\p{Script_Extensions=Anatolian_Hieroglyphs}', 'u', { + unicodePropertyEscapes: 'transform' + }); + // → '[\\u{14400}-\\u{14646}]' + + rewritePattern('\\p{Script_Extensions=Anatolian_Hieroglyphs}', 'u', { + unicodeFlag: 'transform', + unicodePropertyEscapes: 'transform' + }); + // → '(?:\\uD811[\\uDC00-\\uDE46])' + ``` + +- `namedGroups` - [Named capture groups](https://github.com/tc39/proposal-regexp-named-groups). + + ```js + rewritePattern('(?.)\\k', '', { + namedGroups: 'transform' + }); + // → '(.)\1' + ``` + +- `unicodeSetsFlag` - [The `v` (`unicodeSets`) flag](https://github.com/tc39/proposal-regexp-set-notation) + + ```js + rewritePattern('[\\p{Emoji}&&\\p{ASCII}]', 'v', { + unicodeSetsFlag: 'transform' + }); + // → '[#\\*0-9]' + ``` + + By default, patterns with the `v` flag are transformed to patterns with the `u` flag. If you want to downlevel them more you can set the `unicodeFlag: 'transform'` option. + + ```js + rewritePattern('[^[a-h]&&[f-z]]', 'v', { + unicodeSetsFlag: 'transform' + }); + // → '[^f-h]' (to be used with /u) + ``` + + ```js + rewritePattern('[^[a-h]&&[f-z]]', 'v', { + unicodeSetsFlag: 'transform', + unicodeFlag: 'transform' + }); + // → '(?:(?![f-h])[\s\S])' (to be used without /u) + ``` + +- `modifiers` - [Inline `i`/`m`/`s` modifiers](https://github.com/tc39/proposal-regexp-modifiers) + + ```js + rewritePattern('(?i:[a-z])[a-z]', '', { + modifiers: 'transform' + }); + // → '(?:[a-zA-Z])([a-z])' + ``` + +#### Experimental regular expression features + +These options can be set to `false`, `'parse'` and `'transform'`. When using `'transform'`, the corresponding features are compiled to older syntax that can run in older browsers. When using `'parse'`, they are parsed and left as-is in the output pattern. When using `false` (the default), they result in a syntax error if used. + +Once these features become stable (when the proposals are accepted as part of ECMAScript), they will be parsed by default and thus `'parse'` will behave like `false`. + +#### Miscellaneous options + +- `onNamedGroup` + + This option is a function that gets called when a named capture group is found. It receives two parameters: + the name of the group, and its index. + + ```js + rewritePattern('(?.)\\k', '', { + onNamedGroup(name, index) { + console.log(name, index); + // → 'name', 1 + } + }); + ``` + +- `onNewFlags` + + This option is a function that gets called to pass the flags that the resulting pattern must be interpreted with. + + ```js + rewritePattern('abc', 'um', '', { + unicodeFlag: 'transform', + onNewFlags(flags) { + console.log(flags); + // → 'm' + } + }) + ``` + +### Caveats + +- [Lookbehind assertions](https://github.com/tc39/proposal-regexp-lookbehind) cannot be transformed to older syntax. +- When using `namedGroups: 'transform'`, _regexpu-core_ only takes care of the _syntax_: you will still need a runtime wrapper around the regular expression to populate the `.groups` property of `RegExp.prototype.match()`'s result. If you are using _regexpu-core_ via Babel, it's handled automatically. + +## For maintainers + +### How to publish a new release + +1. On the `main` branch, bump the version number in `package.json`: + + ```sh + npm version patch -m 'Release v%s' + ``` + + Instead of `patch`, use `minor` or `major` [as needed](https://semver.org/). + + Note that this produces a Git commit + tag. + +1. Push the release commit and tag: + + ```sh + git push --follow-tags + ``` + + Our CI then automatically publishes the new release to npm. + +1. Once the release has been published to npm, update [`regexpu`](https://github.com/mathiasbynens/regexpu) to make use of it, and [cut a new release of `regexpu` as well](https://github.com/mathiasbynens/regexpu#how-to-publish-a-new-release). + + +## Author + +| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") | +|---| +| [Mathias Bynens](https://mathiasbynens.be/) | + +## License + +_regexpu-core_ is available under the [MIT](https://mths.be/mit) license. diff --git a/tools/ui/node_modules/regexpu-core/data/all-characters.js b/tools/ui/node_modules/regexpu-core/data/all-characters.js new file mode 100644 index 0000000000000000000000000000000000000000..800658cc4fd16a3643d5386a6c7dd89ec920a94c --- /dev/null +++ b/tools/ui/node_modules/regexpu-core/data/all-characters.js @@ -0,0 +1,100 @@ +// Generated using `npm run build`. Do not edit. +'use strict'; + +const regenerate = require('regenerate'); + +exports.UNICODE_SET = regenerate() + .addRange(0x0, 0x10FFFF) + +exports.UNICODE_IV_SET = regenerate(0xD7, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x133, 0x135, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x17E, 0x180, 0x183, 0x185, 0x188, 0x192, 0x195, 0x19E, 0x1A1, 0x1A3, 0x1A5, 0x1A8, 0x1AD, 0x1B0, 0x1B4, 0x1B6, 0x1C6, 0x1C9, 0x1CC, 0x1CE, 0x1D0, 0x1D2, 0x1D4, 0x1D6, 0x1D8, 0x1DA, 0x1DF, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x1E9, 0x1EB, 0x1ED, 0x1F3, 0x1F5, 0x1F9, 0x1FB, 0x1FD, 0x1FF, 0x201, 0x203, 0x205, 0x207, 0x209, 0x20B, 0x20D, 0x20F, 0x211, 0x213, 0x215, 0x217, 0x219, 0x21B, 0x21D, 0x21F, 0x221, 0x223, 0x225, 0x227, 0x229, 0x22B, 0x22D, 0x22F, 0x231, 0x23C, 0x242, 0x247, 0x249, 0x24B, 0x24D, 0x371, 0x387, 0x38B, 0x38D, 0x390, 0x3A2, 0x3D7, 0x3D9, 0x3DB, 0x3DD, 0x3DF, 0x3E1, 0x3E3, 0x3E5, 0x3E7, 0x3E9, 0x3EB, 0x3ED, 0x3EF, 0x3F6, 0x3F8, 0x461, 0x463, 0x465, 0x467, 0x469, 0x46B, 0x46D, 0x46F, 0x471, 0x473, 0x475, 0x477, 0x479, 0x47B, 0x47D, 0x47F, 0x48B, 0x48D, 0x48F, 0x491, 0x493, 0x495, 0x497, 0x499, 0x49B, 0x49D, 0x49F, 0x4A1, 0x4A3, 0x4A5, 0x4A7, 0x4A9, 0x4AB, 0x4AD, 0x4AF, 0x4B1, 0x4B3, 0x4B5, 0x4B7, 0x4B9, 0x4BB, 0x4BD, 0x4BF, 0x4C2, 0x4C4, 0x4C6, 0x4C8, 0x4CA, 0x4CC, 0x4D1, 0x4D3, 0x4D5, 0x4D7, 0x4D9, 0x4DB, 0x4DD, 0x4DF, 0x4E1, 0x4E3, 0x4E5, 0x4E7, 0x4E9, 0x4EB, 0x4ED, 0x4EF, 0x4F1, 0x4F3, 0x4F5, 0x4F7, 0x4F9, 0x4FB, 0x4FD, 0x4FF, 0x501, 0x503, 0x505, 0x507, 0x509, 0x50B, 0x50D, 0x50F, 0x511, 0x513, 0x515, 0x517, 0x519, 0x51B, 0x51D, 0x51F, 0x521, 0x523, 0x525, 0x527, 0x529, 0x52B, 0x52D, 0x10C6, 0x1E01, 0x1E03, 0x1E05, 0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13, 0x1E15, 0x1E17, 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27, 0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39, 0x1E3B, 0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F, 0x1E51, 0x1E53, 0x1E55, 0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63, 0x1E65, 0x1E67, 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77, 0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89, 0x1E8B, 0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1E9F, 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9, 0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, 0x1ED1, 0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EE3, 0x1EE5, 0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9, 0x1EFB, 0x1EFD, 0x1F5A, 0x1F5C, 0x1F5E, 0x1FBD, 0x2C61, 0x2C68, 0x2C6A, 0x2C6C, 0x2C71, 0x2C81, 0x2C83, 0x2C85, 0x2C87, 0x2C89, 0x2C8B, 0x2C8D, 0x2C8F, 0x2C91, 0x2C93, 0x2C95, 0x2C97, 0x2C99, 0x2C9B, 0x2C9D, 0x2C9F, 0x2CA1, 0x2CA3, 0x2CA5, 0x2CA7, 0x2CA9, 0x2CAB, 0x2CAD, 0x2CAF, 0x2CB1, 0x2CB3, 0x2CB5, 0x2CB7, 0x2CB9, 0x2CBB, 0x2CBD, 0x2CBF, 0x2CC1, 0x2CC3, 0x2CC5, 0x2CC7, 0x2CC9, 0x2CCB, 0x2CCD, 0x2CCF, 0x2CD1, 0x2CD3, 0x2CD5, 0x2CD7, 0x2CD9, 0x2CDB, 0x2CDD, 0x2CDF, 0x2CE1, 0x2CEC, 0xA641, 0xA643, 0xA645, 0xA647, 0xA649, 0xA64B, 0xA64D, 0xA64F, 0xA651, 0xA653, 0xA655, 0xA657, 0xA659, 0xA65B, 0xA65D, 0xA65F, 0xA661, 0xA663, 0xA665, 0xA667, 0xA669, 0xA66B, 0xA681, 0xA683, 0xA685, 0xA687, 0xA689, 0xA68B, 0xA68D, 0xA68F, 0xA691, 0xA693, 0xA695, 0xA697, 0xA699, 0xA723, 0xA725, 0xA727, 0xA729, 0xA72B, 0xA72D, 0xA733, 0xA735, 0xA737, 0xA739, 0xA73B, 0xA73D, 0xA73F, 0xA741, 0xA743, 0xA745, 0xA747, 0xA749, 0xA74B, 0xA74D, 0xA74F, 0xA751, 0xA753, 0xA755, 0xA757, 0xA759, 0xA75B, 0xA75D, 0xA75F, 0xA761, 0xA763, 0xA765, 0xA767, 0xA769, 0xA76B, 0xA76D, 0xA77A, 0xA77C, 0xA77F, 0xA781, 0xA783, 0xA785, 0xA78C, 0xA791, 0xA797, 0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3, 0xA7A5, 0xA7A7, 0xA7A9, 0xA7AF, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C1, 0xA7C3, 0xA7C8, 0xA7CA, 0xA7CD, 0xA7CF, 0xA7D1, 0xA7D3, 0xA7D5, 0xA7D7, 0xA7D9, 0xA7DB, 0x1057B, 0x1058B, 0x10593) + .addRange(0x0, 0x40) + .addRange(0x5B, 0xB4) + .addRange(0xB6, 0xBF) + .addRange(0xDF, 0xFF) + .addRange(0x12F, 0x131) + .addRange(0x137, 0x138) + .addRange(0x148, 0x149) + .addRange(0x18C, 0x18D) + .addRange(0x199, 0x19B) + .addRange(0x1AA, 0x1AB) + .addRange(0x1B9, 0x1BB) + .addRange(0x1BD, 0x1C3) + .addRange(0x1DC, 0x1DD) + .addRange(0x1EF, 0x1F0) + .addRange(0x233, 0x239) + .addRange(0x23F, 0x240) + .addRange(0x24F, 0x344) + .addRange(0x346, 0x36F) + .addRange(0x373, 0x375) + .addRange(0x377, 0x37E) + .addRange(0x380, 0x385) + .addRange(0x3AC, 0x3C1) + .addRange(0x3C3, 0x3CE) + .addRange(0x3D2, 0x3D4) + .addRange(0x3F2, 0x3F3) + .addRange(0x3FB, 0x3FC) + .addRange(0x430, 0x45F) + .addRange(0x481, 0x489) + .addRange(0x4CE, 0x4CF) + .addRange(0x52F, 0x530) + .addRange(0x557, 0x109F) + .addRange(0x10C8, 0x10CC) + .addRange(0x10CE, 0x13F7) + .addRange(0x13FE, 0x1C7F) + .addRange(0x1C8A, 0x1C8F) + .addRange(0x1CBB, 0x1CBC) + .addRange(0x1CC0, 0x1DFF) + .addRange(0x1E95, 0x1E9A) + .addRange(0x1E9C, 0x1E9D) + .addRange(0x1EFF, 0x1F07) + .addRange(0x1F10, 0x1F17) + .addRange(0x1F1E, 0x1F27) + .addRange(0x1F30, 0x1F37) + .addRange(0x1F40, 0x1F47) + .addRange(0x1F4E, 0x1F58) + .addRange(0x1F60, 0x1F67) + .addRange(0x1F70, 0x1F87) + .addRange(0x1F90, 0x1F97) + .addRange(0x1FA0, 0x1FA7) + .addRange(0x1FB0, 0x1FB7) + .addRange(0x1FBF, 0x1FC7) + .addRange(0x1FCD, 0x1FD2) + .addRange(0x1FD4, 0x1FD7) + .addRange(0x1FDC, 0x1FE2) + .addRange(0x1FE4, 0x1FE7) + .addRange(0x1FED, 0x1FF7) + .addRange(0x1FFD, 0x2125) + .addRange(0x2127, 0x2129) + .addRange(0x212C, 0x2131) + .addRange(0x2133, 0x215F) + .addRange(0x2170, 0x2182) + .addRange(0x2184, 0x24B5) + .addRange(0x24D0, 0x2BFF) + .addRange(0x2C30, 0x2C5F) + .addRange(0x2C65, 0x2C66) + .addRange(0x2C73, 0x2C74) + .addRange(0x2C76, 0x2C7D) + .addRange(0x2CE3, 0x2CEA) + .addRange(0x2CEE, 0x2CF1) + .addRange(0x2CF3, 0xA63F) + .addRange(0xA66D, 0xA67F) + .addRange(0xA69B, 0xA721) + .addRange(0xA72F, 0xA731) + .addRange(0xA76F, 0xA778) + .addRange(0xA787, 0xA78A) + .addRange(0xA78E, 0xA78F) + .addRange(0xA793, 0xA795) + .addRange(0xA7DD, 0xA7F4) + .addRange(0xA7F6, 0xAB6F) + .addRange(0xABC0, 0xFB04) + .addRange(0xFB06, 0xFF20) + .addRange(0xFF3B, 0x103FF) + .addRange(0x10428, 0x104AF) + .addRange(0x104D4, 0x1056F) + .addRange(0x10596, 0x10C7F) + .addRange(0x10CB3, 0x10D4F) + .addRange(0x10D66, 0x1189F) + .addRange(0x118C0, 0x16E3F) + .addRange(0x16E60, 0x16E9F) + .addRange(0x16EB9, 0x1E8FF) + .addRange(0x1E922, 0x10FFFF) diff --git a/tools/ui/node_modules/regexpu-core/data/character-class-escape-sets.js b/tools/ui/node_modules/regexpu-core/data/character-class-escape-sets.js new file mode 100644 index 0000000000000000000000000000000000000000..6c1309bce3bdf02047a1aa3e07d6327d29d53033 --- /dev/null +++ b/tools/ui/node_modules/regexpu-core/data/character-class-escape-sets.js @@ -0,0 +1,127 @@ +// Generated using `npm run build`. Do not edit. +'use strict'; + +const regenerate = require('regenerate'); +const UNICODE_IV_SET = require('./all-characters.js').UNICODE_IV_SET; + +exports.REGULAR = new Map([ + ['d', regenerate() + .addRange(0x30, 0x39)], + ['D', regenerate() + .addRange(0x0, 0x2F) + .addRange(0x3A, 0xFFFF)], + ['s', regenerate(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000, 0xFEFF) + .addRange(0x9, 0xD) + .addRange(0x2000, 0x200A) + .addRange(0x2028, 0x2029)], + ['S', regenerate() + .addRange(0x0, 0x8) + .addRange(0xE, 0x1F) + .addRange(0x21, 0x9F) + .addRange(0xA1, 0x167F) + .addRange(0x1681, 0x1FFF) + .addRange(0x200B, 0x2027) + .addRange(0x202A, 0x202E) + .addRange(0x2030, 0x205E) + .addRange(0x2060, 0x2FFF) + .addRange(0x3001, 0xFEFE) + .addRange(0xFF00, 0xFFFF)], + ['w', regenerate(0x5F) + .addRange(0x30, 0x39) + .addRange(0x41, 0x5A) + .addRange(0x61, 0x7A)], + ['W', regenerate(0x60) + .addRange(0x0, 0x2F) + .addRange(0x3A, 0x40) + .addRange(0x5B, 0x5E) + .addRange(0x7B, 0xFFFF)] +]); + +exports.UNICODE = new Map([ + ['d', regenerate() + .addRange(0x30, 0x39)], + ['D', regenerate() + .addRange(0x0, 0x2F) + .addRange(0x3A, 0x10FFFF)], + ['s', regenerate(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000, 0xFEFF) + .addRange(0x9, 0xD) + .addRange(0x2000, 0x200A) + .addRange(0x2028, 0x2029)], + ['S', regenerate() + .addRange(0x0, 0x8) + .addRange(0xE, 0x1F) + .addRange(0x21, 0x9F) + .addRange(0xA1, 0x167F) + .addRange(0x1681, 0x1FFF) + .addRange(0x200B, 0x2027) + .addRange(0x202A, 0x202E) + .addRange(0x2030, 0x205E) + .addRange(0x2060, 0x2FFF) + .addRange(0x3001, 0xFEFE) + .addRange(0xFF00, 0x10FFFF)], + ['w', regenerate(0x5F) + .addRange(0x30, 0x39) + .addRange(0x41, 0x5A) + .addRange(0x61, 0x7A)], + ['W', regenerate(0x60) + .addRange(0x0, 0x2F) + .addRange(0x3A, 0x40) + .addRange(0x5B, 0x5E) + .addRange(0x7B, 0x10FFFF)] +]); + +exports.UNICODE_IGNORE_CASE = new Map([ + ['d', regenerate() + .addRange(0x30, 0x39)], + ['D', regenerate() + .addRange(0x0, 0x2F) + .addRange(0x3A, 0x10FFFF)], + ['s', regenerate(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000, 0xFEFF) + .addRange(0x9, 0xD) + .addRange(0x2000, 0x200A) + .addRange(0x2028, 0x2029)], + ['S', regenerate() + .addRange(0x0, 0x8) + .addRange(0xE, 0x1F) + .addRange(0x21, 0x9F) + .addRange(0xA1, 0x167F) + .addRange(0x1681, 0x1FFF) + .addRange(0x200B, 0x2027) + .addRange(0x202A, 0x202E) + .addRange(0x2030, 0x205E) + .addRange(0x2060, 0x2FFF) + .addRange(0x3001, 0xFEFE) + .addRange(0xFF00, 0x10FFFF)], + ['w', regenerate(0x5F, 0x17F, 0x212A) + .addRange(0x30, 0x39) + .addRange(0x41, 0x5A) + .addRange(0x61, 0x7A)], + ['W', regenerate(0x60) + .addRange(0x0, 0x2F) + .addRange(0x3A, 0x40) + .addRange(0x5B, 0x5E) + .addRange(0x7B, 0x17E) + .addRange(0x180, 0x2129) + .addRange(0x212B, 0x10FFFF)] +]); + +exports.UNICODESET_IGNORE_CASE = new Map([ + ['d', regenerate() + .addRange(0x30, 0x39)], + ['D', UNICODE_IV_SET.clone().remove(regenerate() + .addRange(0x30, 0x39))], + ['s', regenerate(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000, 0xFEFF) + .addRange(0x9, 0xD) + .addRange(0x2000, 0x200A) + .addRange(0x2028, 0x2029)], + ['S', UNICODE_IV_SET.clone().remove(regenerate(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000, 0xFEFF) + .addRange(0x9, 0xD) + .addRange(0x2000, 0x200A) + .addRange(0x2028, 0x2029))], + ['w', regenerate(0x5F) + .addRange(0x30, 0x39) + .addRange(0x61, 0x7A)], + ['W', UNICODE_IV_SET.clone().remove(regenerate(0x5F) + .addRange(0x30, 0x39) + .addRange(0x61, 0x7A))] +]); diff --git a/tools/ui/node_modules/regexpu-core/data/i-bmp-mappings.js b/tools/ui/node_modules/regexpu-core/data/i-bmp-mappings.js new file mode 100644 index 0000000000000000000000000000000000000000..599573fbf71c685e571315e2c820300df1aa8a04 --- /dev/null +++ b/tools/ui/node_modules/regexpu-core/data/i-bmp-mappings.js @@ -0,0 +1,2334 @@ +module.exports = new Map([ + [0xB5, 0x3BC], + [0xC0, 0xE0], + [0xC1, 0xE1], + [0xC2, 0xE2], + [0xC3, 0xE3], + [0xC4, 0xE4], + [0xC5, 0xE5], + [0xC6, 0xE6], + [0xC7, 0xE7], + [0xC8, 0xE8], + [0xC9, 0xE9], + [0xCA, 0xEA], + [0xCB, 0xEB], + [0xCC, 0xEC], + [0xCD, 0xED], + [0xCE, 0xEE], + [0xCF, 0xEF], + [0xD0, 0xF0], + [0xD1, 0xF1], + [0xD2, 0xF2], + [0xD3, 0xF3], + [0xD4, 0xF4], + [0xD5, 0xF5], + [0xD6, 0xF6], + [0xD8, 0xF8], + [0xD9, 0xF9], + [0xDA, 0xFA], + [0xDB, 0xFB], + [0xDC, 0xFC], + [0xDD, 0xFD], + [0xDE, 0xFE], + [0xE0, 0xC0], + [0xE1, 0xC1], + [0xE2, 0xC2], + [0xE3, 0xC3], + [0xE4, 0xC4], + [0xE5, 0xC5], + [0xE6, 0xC6], + [0xE7, 0xC7], + [0xE8, 0xC8], + [0xE9, 0xC9], + [0xEA, 0xCA], + [0xEB, 0xCB], + [0xEC, 0xCC], + [0xED, 0xCD], + [0xEE, 0xCE], + [0xEF, 0xCF], + [0xF0, 0xD0], + [0xF1, 0xD1], + [0xF2, 0xD2], + [0xF3, 0xD3], + [0xF4, 0xD4], + [0xF5, 0xD5], + [0xF6, 0xD6], + [0xF8, 0xD8], + [0xF9, 0xD9], + [0xFA, 0xDA], + [0xFB, 0xDB], + [0xFC, 0xDC], + [0xFD, 0xDD], + [0xFE, 0xDE], + [0xFF, 0x178], + [0x100, 0x101], + [0x101, 0x100], + [0x102, 0x103], + [0x103, 0x102], + [0x104, 0x105], + [0x105, 0x104], + [0x106, 0x107], + [0x107, 0x106], + [0x108, 0x109], + [0x109, 0x108], + [0x10A, 0x10B], + [0x10B, 0x10A], + [0x10C, 0x10D], + [0x10D, 0x10C], + [0x10E, 0x10F], + [0x10F, 0x10E], + [0x110, 0x111], + [0x111, 0x110], + [0x112, 0x113], + [0x113, 0x112], + [0x114, 0x115], + [0x115, 0x114], + [0x116, 0x117], + [0x117, 0x116], + [0x118, 0x119], + [0x119, 0x118], + [0x11A, 0x11B], + [0x11B, 0x11A], + [0x11C, 0x11D], + [0x11D, 0x11C], + [0x11E, 0x11F], + [0x11F, 0x11E], + [0x120, 0x121], + [0x121, 0x120], + [0x122, 0x123], + [0x123, 0x122], + [0x124, 0x125], + [0x125, 0x124], + [0x126, 0x127], + [0x127, 0x126], + [0x128, 0x129], + [0x129, 0x128], + [0x12A, 0x12B], + [0x12B, 0x12A], + [0x12C, 0x12D], + [0x12D, 0x12C], + [0x12E, 0x12F], + [0x12F, 0x12E], + [0x132, 0x133], + [0x133, 0x132], + [0x134, 0x135], + [0x135, 0x134], + [0x136, 0x137], + [0x137, 0x136], + [0x139, 0x13A], + [0x13A, 0x139], + [0x13B, 0x13C], + [0x13C, 0x13B], + [0x13D, 0x13E], + [0x13E, 0x13D], + [0x13F, 0x140], + [0x140, 0x13F], + [0x141, 0x142], + [0x142, 0x141], + [0x143, 0x144], + [0x144, 0x143], + [0x145, 0x146], + [0x146, 0x145], + [0x147, 0x148], + [0x148, 0x147], + [0x14A, 0x14B], + [0x14B, 0x14A], + [0x14C, 0x14D], + [0x14D, 0x14C], + [0x14E, 0x14F], + [0x14F, 0x14E], + [0x150, 0x151], + [0x151, 0x150], + [0x152, 0x153], + [0x153, 0x152], + [0x154, 0x155], + [0x155, 0x154], + [0x156, 0x157], + [0x157, 0x156], + [0x158, 0x159], + [0x159, 0x158], + [0x15A, 0x15B], + [0x15B, 0x15A], + [0x15C, 0x15D], + [0x15D, 0x15C], + [0x15E, 0x15F], + [0x15F, 0x15E], + [0x160, 0x161], + [0x161, 0x160], + [0x162, 0x163], + [0x163, 0x162], + [0x164, 0x165], + [0x165, 0x164], + [0x166, 0x167], + [0x167, 0x166], + [0x168, 0x169], + [0x169, 0x168], + [0x16A, 0x16B], + [0x16B, 0x16A], + [0x16C, 0x16D], + [0x16D, 0x16C], + [0x16E, 0x16F], + [0x16F, 0x16E], + [0x170, 0x171], + [0x171, 0x170], + [0x172, 0x173], + [0x173, 0x172], + [0x174, 0x175], + [0x175, 0x174], + [0x176, 0x177], + [0x177, 0x176], + [0x178, 0xFF], + [0x179, 0x17A], + [0x17A, 0x179], + [0x17B, 0x17C], + [0x17C, 0x17B], + [0x17D, 0x17E], + [0x17E, 0x17D], + [0x180, 0x243], + [0x181, 0x253], + [0x182, 0x183], + [0x183, 0x182], + [0x184, 0x185], + [0x185, 0x184], + [0x186, 0x254], + [0x187, 0x188], + [0x188, 0x187], + [0x189, 0x256], + [0x18A, 0x257], + [0x18B, 0x18C], + [0x18C, 0x18B], + [0x18E, 0x1DD], + [0x18F, 0x259], + [0x190, 0x25B], + [0x191, 0x192], + [0x192, 0x191], + [0x193, 0x260], + [0x194, 0x263], + [0x195, 0x1F6], + [0x196, 0x269], + [0x197, 0x268], + [0x198, 0x199], + [0x199, 0x198], + [0x19A, 0x23D], + [0x19B, 0xA7DC], + [0x19C, 0x26F], + [0x19D, 0x272], + [0x19E, 0x220], + [0x19F, 0x275], + [0x1A0, 0x1A1], + [0x1A1, 0x1A0], + [0x1A2, 0x1A3], + [0x1A3, 0x1A2], + [0x1A4, 0x1A5], + [0x1A5, 0x1A4], + [0x1A6, 0x280], + [0x1A7, 0x1A8], + [0x1A8, 0x1A7], + [0x1A9, 0x283], + [0x1AC, 0x1AD], + [0x1AD, 0x1AC], + [0x1AE, 0x288], + [0x1AF, 0x1B0], + [0x1B0, 0x1AF], + [0x1B1, 0x28A], + [0x1B2, 0x28B], + [0x1B3, 0x1B4], + [0x1B4, 0x1B3], + [0x1B5, 0x1B6], + [0x1B6, 0x1B5], + [0x1B7, 0x292], + [0x1B8, 0x1B9], + [0x1B9, 0x1B8], + [0x1BC, 0x1BD], + [0x1BD, 0x1BC], + [0x1BF, 0x1F7], + [0x1C4, 0x1C6], + [0x1C5, 0x1C6], + [0x1C6, [ + 0x1C4, + 0x1C5 + ]], + [0x1C7, 0x1C9], + [0x1C8, 0x1C9], + [0x1C9, [ + 0x1C7, + 0x1C8 + ]], + [0x1CA, 0x1CC], + [0x1CB, 0x1CC], + [0x1CC, [ + 0x1CA, + 0x1CB + ]], + [0x1CD, 0x1CE], + [0x1CE, 0x1CD], + [0x1CF, 0x1D0], + [0x1D0, 0x1CF], + [0x1D1, 0x1D2], + [0x1D2, 0x1D1], + [0x1D3, 0x1D4], + [0x1D4, 0x1D3], + [0x1D5, 0x1D6], + [0x1D6, 0x1D5], + [0x1D7, 0x1D8], + [0x1D8, 0x1D7], + [0x1D9, 0x1DA], + [0x1DA, 0x1D9], + [0x1DB, 0x1DC], + [0x1DC, 0x1DB], + [0x1DD, 0x18E], + [0x1DE, 0x1DF], + [0x1DF, 0x1DE], + [0x1E0, 0x1E1], + [0x1E1, 0x1E0], + [0x1E2, 0x1E3], + [0x1E3, 0x1E2], + [0x1E4, 0x1E5], + [0x1E5, 0x1E4], + [0x1E6, 0x1E7], + [0x1E7, 0x1E6], + [0x1E8, 0x1E9], + [0x1E9, 0x1E8], + [0x1EA, 0x1EB], + [0x1EB, 0x1EA], + [0x1EC, 0x1ED], + [0x1ED, 0x1EC], + [0x1EE, 0x1EF], + [0x1EF, 0x1EE], + [0x1F1, 0x1F3], + [0x1F2, 0x1F3], + [0x1F3, [ + 0x1F1, + 0x1F2 + ]], + [0x1F4, 0x1F5], + [0x1F5, 0x1F4], + [0x1F6, 0x195], + [0x1F7, 0x1BF], + [0x1F8, 0x1F9], + [0x1F9, 0x1F8], + [0x1FA, 0x1FB], + [0x1FB, 0x1FA], + [0x1FC, 0x1FD], + [0x1FD, 0x1FC], + [0x1FE, 0x1FF], + [0x1FF, 0x1FE], + [0x200, 0x201], + [0x201, 0x200], + [0x202, 0x203], + [0x203, 0x202], + [0x204, 0x205], + [0x205, 0x204], + [0x206, 0x207], + [0x207, 0x206], + [0x208, 0x209], + [0x209, 0x208], + [0x20A, 0x20B], + [0x20B, 0x20A], + [0x20C, 0x20D], + [0x20D, 0x20C], + [0x20E, 0x20F], + [0x20F, 0x20E], + [0x210, 0x211], + [0x211, 0x210], + [0x212, 0x213], + [0x213, 0x212], + [0x214, 0x215], + [0x215, 0x214], + [0x216, 0x217], + [0x217, 0x216], + [0x218, 0x219], + [0x219, 0x218], + [0x21A, 0x21B], + [0x21B, 0x21A], + [0x21C, 0x21D], + [0x21D, 0x21C], + [0x21E, 0x21F], + [0x21F, 0x21E], + [0x220, 0x19E], + [0x222, 0x223], + [0x223, 0x222], + [0x224, 0x225], + [0x225, 0x224], + [0x226, 0x227], + [0x227, 0x226], + [0x228, 0x229], + [0x229, 0x228], + [0x22A, 0x22B], + [0x22B, 0x22A], + [0x22C, 0x22D], + [0x22D, 0x22C], + [0x22E, 0x22F], + [0x22F, 0x22E], + [0x230, 0x231], + [0x231, 0x230], + [0x232, 0x233], + [0x233, 0x232], + [0x23A, 0x2C65], + [0x23B, 0x23C], + [0x23C, 0x23B], + [0x23D, 0x19A], + [0x23E, 0x2C66], + [0x23F, 0x2C7E], + [0x240, 0x2C7F], + [0x241, 0x242], + [0x242, 0x241], + [0x243, 0x180], + [0x244, 0x289], + [0x245, 0x28C], + [0x246, 0x247], + [0x247, 0x246], + [0x248, 0x249], + [0x249, 0x248], + [0x24A, 0x24B], + [0x24B, 0x24A], + [0x24C, 0x24D], + [0x24D, 0x24C], + [0x24E, 0x24F], + [0x24F, 0x24E], + [0x250, 0x2C6F], + [0x251, 0x2C6D], + [0x252, 0x2C70], + [0x253, 0x181], + [0x254, 0x186], + [0x256, 0x189], + [0x257, 0x18A], + [0x259, 0x18F], + [0x25B, 0x190], + [0x25C, 0xA7AB], + [0x260, 0x193], + [0x261, 0xA7AC], + [0x263, 0x194], + [0x264, 0xA7CB], + [0x265, 0xA78D], + [0x266, 0xA7AA], + [0x268, 0x197], + [0x269, 0x196], + [0x26A, 0xA7AE], + [0x26B, 0x2C62], + [0x26C, 0xA7AD], + [0x26F, 0x19C], + [0x271, 0x2C6E], + [0x272, 0x19D], + [0x275, 0x19F], + [0x27D, 0x2C64], + [0x280, 0x1A6], + [0x282, 0xA7C5], + [0x283, 0x1A9], + [0x287, 0xA7B1], + [0x288, 0x1AE], + [0x289, 0x244], + [0x28A, 0x1B1], + [0x28B, 0x1B2], + [0x28C, 0x245], + [0x292, 0x1B7], + [0x29D, 0xA7B2], + [0x29E, 0xA7B0], + [0x345, 0x3B9], + [0x370, 0x371], + [0x371, 0x370], + [0x372, 0x373], + [0x373, 0x372], + [0x376, 0x377], + [0x377, 0x376], + [0x37B, 0x3FD], + [0x37C, 0x3FE], + [0x37D, 0x3FF], + [0x37F, 0x3F3], + [0x386, 0x3AC], + [0x388, 0x3AD], + [0x389, 0x3AE], + [0x38A, 0x3AF], + [0x38C, 0x3CC], + [0x38E, 0x3CD], + [0x38F, 0x3CE], + [0x391, 0x3B1], + [0x392, 0x3B2], + [0x393, 0x3B3], + [0x394, 0x3B4], + [0x395, 0x3B5], + [0x396, 0x3B6], + [0x397, 0x3B7], + [0x398, 0x3B8], + [0x399, 0x3B9], + [0x39A, 0x3BA], + [0x39B, 0x3BB], + [0x39C, 0x3BC], + [0x39D, 0x3BD], + [0x39E, 0x3BE], + [0x39F, 0x3BF], + [0x3A0, 0x3C0], + [0x3A1, 0x3C1], + [0x3A3, 0x3C3], + [0x3A4, 0x3C4], + [0x3A5, 0x3C5], + [0x3A6, 0x3C6], + [0x3A7, 0x3C7], + [0x3A8, 0x3C8], + [0x3A9, 0x3C9], + [0x3AA, 0x3CA], + [0x3AB, 0x3CB], + [0x3AC, 0x386], + [0x3AD, 0x388], + [0x3AE, 0x389], + [0x3AF, 0x38A], + [0x3B1, 0x391], + [0x3B2, [ + 0x392, + 0x3D0 + ]], + [0x3B3, 0x393], + [0x3B4, 0x394], + [0x3B5, [ + 0x395, + 0x3F5 + ]], + [0x3B6, 0x396], + [0x3B7, 0x397], + [0x3B8, [ + 0x398, + 0x3D1 + ]], + [0x3B9, [ + 0x345, + 0x399, + 0x1FBE + ]], + [0x3BA, [ + 0x39A, + 0x3F0 + ]], + [0x3BB, 0x39B], + [0x3BC, [ + 0xB5, + 0x39C + ]], + [0x3BD, 0x39D], + [0x3BE, 0x39E], + [0x3BF, 0x39F], + [0x3C0, [ + 0x3A0, + 0x3D6 + ]], + [0x3C1, [ + 0x3A1, + 0x3F1 + ]], + [0x3C2, 0x3C3], + [0x3C3, [ + 0x3A3, + 0x3C2 + ]], + [0x3C4, 0x3A4], + [0x3C5, 0x3A5], + [0x3C6, [ + 0x3A6, + 0x3D5 + ]], + [0x3C7, 0x3A7], + [0x3C8, 0x3A8], + [0x3C9, 0x3A9], + [0x3CA, 0x3AA], + [0x3CB, 0x3AB], + [0x3CC, 0x38C], + [0x3CD, 0x38E], + [0x3CE, 0x38F], + [0x3CF, 0x3D7], + [0x3D0, 0x3B2], + [0x3D1, 0x3B8], + [0x3D5, 0x3C6], + [0x3D6, 0x3C0], + [0x3D7, 0x3CF], + [0x3D8, 0x3D9], + [0x3D9, 0x3D8], + [0x3DA, 0x3DB], + [0x3DB, 0x3DA], + [0x3DC, 0x3DD], + [0x3DD, 0x3DC], + [0x3DE, 0x3DF], + [0x3DF, 0x3DE], + [0x3E0, 0x3E1], + [0x3E1, 0x3E0], + [0x3E2, 0x3E3], + [0x3E3, 0x3E2], + [0x3E4, 0x3E5], + [0x3E5, 0x3E4], + [0x3E6, 0x3E7], + [0x3E7, 0x3E6], + [0x3E8, 0x3E9], + [0x3E9, 0x3E8], + [0x3EA, 0x3EB], + [0x3EB, 0x3EA], + [0x3EC, 0x3ED], + [0x3ED, 0x3EC], + [0x3EE, 0x3EF], + [0x3EF, 0x3EE], + [0x3F0, 0x3BA], + [0x3F1, 0x3C1], + [0x3F2, 0x3F9], + [0x3F3, 0x37F], + [0x3F5, 0x3B5], + [0x3F7, 0x3F8], + [0x3F8, 0x3F7], + [0x3F9, 0x3F2], + [0x3FA, 0x3FB], + [0x3FB, 0x3FA], + [0x3FD, 0x37B], + [0x3FE, 0x37C], + [0x3FF, 0x37D], + [0x400, 0x450], + [0x401, 0x451], + [0x402, 0x452], + [0x403, 0x453], + [0x404, 0x454], + [0x405, 0x455], + [0x406, 0x456], + [0x407, 0x457], + [0x408, 0x458], + [0x409, 0x459], + [0x40A, 0x45A], + [0x40B, 0x45B], + [0x40C, 0x45C], + [0x40D, 0x45D], + [0x40E, 0x45E], + [0x40F, 0x45F], + [0x410, 0x430], + [0x411, 0x431], + [0x412, 0x432], + [0x413, 0x433], + [0x414, 0x434], + [0x415, 0x435], + [0x416, 0x436], + [0x417, 0x437], + [0x418, 0x438], + [0x419, 0x439], + [0x41A, 0x43A], + [0x41B, 0x43B], + [0x41C, 0x43C], + [0x41D, 0x43D], + [0x41E, 0x43E], + [0x41F, 0x43F], + [0x420, 0x440], + [0x421, 0x441], + [0x422, 0x442], + [0x423, 0x443], + [0x424, 0x444], + [0x425, 0x445], + [0x426, 0x446], + [0x427, 0x447], + [0x428, 0x448], + [0x429, 0x449], + [0x42A, 0x44A], + [0x42B, 0x44B], + [0x42C, 0x44C], + [0x42D, 0x44D], + [0x42E, 0x44E], + [0x42F, 0x44F], + [0x430, 0x410], + [0x431, 0x411], + [0x432, [ + 0x412, + 0x1C80 + ]], + [0x433, 0x413], + [0x434, [ + 0x414, + 0x1C81 + ]], + [0x435, 0x415], + [0x436, 0x416], + [0x437, 0x417], + [0x438, 0x418], + [0x439, 0x419], + [0x43A, 0x41A], + [0x43B, 0x41B], + [0x43C, 0x41C], + [0x43D, 0x41D], + [0x43E, [ + 0x41E, + 0x1C82 + ]], + [0x43F, 0x41F], + [0x440, 0x420], + [0x441, [ + 0x421, + 0x1C83 + ]], + [0x442, [ + 0x422, + 0x1C84, + 0x1C85 + ]], + [0x443, 0x423], + [0x444, 0x424], + [0x445, 0x425], + [0x446, 0x426], + [0x447, 0x427], + [0x448, 0x428], + [0x449, 0x429], + [0x44A, [ + 0x42A, + 0x1C86 + ]], + [0x44B, 0x42B], + [0x44C, 0x42C], + [0x44D, 0x42D], + [0x44E, 0x42E], + [0x44F, 0x42F], + [0x450, 0x400], + [0x451, 0x401], + [0x452, 0x402], + [0x453, 0x403], + [0x454, 0x404], + [0x455, 0x405], + [0x456, 0x406], + [0x457, 0x407], + [0x458, 0x408], + [0x459, 0x409], + [0x45A, 0x40A], + [0x45B, 0x40B], + [0x45C, 0x40C], + [0x45D, 0x40D], + [0x45E, 0x40E], + [0x45F, 0x40F], + [0x460, 0x461], + [0x461, 0x460], + [0x462, 0x463], + [0x463, [ + 0x462, + 0x1C87 + ]], + [0x464, 0x465], + [0x465, 0x464], + [0x466, 0x467], + [0x467, 0x466], + [0x468, 0x469], + [0x469, 0x468], + [0x46A, 0x46B], + [0x46B, 0x46A], + [0x46C, 0x46D], + [0x46D, 0x46C], + [0x46E, 0x46F], + [0x46F, 0x46E], + [0x470, 0x471], + [0x471, 0x470], + [0x472, 0x473], + [0x473, 0x472], + [0x474, 0x475], + [0x475, 0x474], + [0x476, 0x477], + [0x477, 0x476], + [0x478, 0x479], + [0x479, 0x478], + [0x47A, 0x47B], + [0x47B, 0x47A], + [0x47C, 0x47D], + [0x47D, 0x47C], + [0x47E, 0x47F], + [0x47F, 0x47E], + [0x480, 0x481], + [0x481, 0x480], + [0x48A, 0x48B], + [0x48B, 0x48A], + [0x48C, 0x48D], + [0x48D, 0x48C], + [0x48E, 0x48F], + [0x48F, 0x48E], + [0x490, 0x491], + [0x491, 0x490], + [0x492, 0x493], + [0x493, 0x492], + [0x494, 0x495], + [0x495, 0x494], + [0x496, 0x497], + [0x497, 0x496], + [0x498, 0x499], + [0x499, 0x498], + [0x49A, 0x49B], + [0x49B, 0x49A], + [0x49C, 0x49D], + [0x49D, 0x49C], + [0x49E, 0x49F], + [0x49F, 0x49E], + [0x4A0, 0x4A1], + [0x4A1, 0x4A0], + [0x4A2, 0x4A3], + [0x4A3, 0x4A2], + [0x4A4, 0x4A5], + [0x4A5, 0x4A4], + [0x4A6, 0x4A7], + [0x4A7, 0x4A6], + [0x4A8, 0x4A9], + [0x4A9, 0x4A8], + [0x4AA, 0x4AB], + [0x4AB, 0x4AA], + [0x4AC, 0x4AD], + [0x4AD, 0x4AC], + [0x4AE, 0x4AF], + [0x4AF, 0x4AE], + [0x4B0, 0x4B1], + [0x4B1, 0x4B0], + [0x4B2, 0x4B3], + [0x4B3, 0x4B2], + [0x4B4, 0x4B5], + [0x4B5, 0x4B4], + [0x4B6, 0x4B7], + [0x4B7, 0x4B6], + [0x4B8, 0x4B9], + [0x4B9, 0x4B8], + [0x4BA, 0x4BB], + [0x4BB, 0x4BA], + [0x4BC, 0x4BD], + [0x4BD, 0x4BC], + [0x4BE, 0x4BF], + [0x4BF, 0x4BE], + [0x4C0, 0x4CF], + [0x4C1, 0x4C2], + [0x4C2, 0x4C1], + [0x4C3, 0x4C4], + [0x4C4, 0x4C3], + [0x4C5, 0x4C6], + [0x4C6, 0x4C5], + [0x4C7, 0x4C8], + [0x4C8, 0x4C7], + [0x4C9, 0x4CA], + [0x4CA, 0x4C9], + [0x4CB, 0x4CC], + [0x4CC, 0x4CB], + [0x4CD, 0x4CE], + [0x4CE, 0x4CD], + [0x4CF, 0x4C0], + [0x4D0, 0x4D1], + [0x4D1, 0x4D0], + [0x4D2, 0x4D3], + [0x4D3, 0x4D2], + [0x4D4, 0x4D5], + [0x4D5, 0x4D4], + [0x4D6, 0x4D7], + [0x4D7, 0x4D6], + [0x4D8, 0x4D9], + [0x4D9, 0x4D8], + [0x4DA, 0x4DB], + [0x4DB, 0x4DA], + [0x4DC, 0x4DD], + [0x4DD, 0x4DC], + [0x4DE, 0x4DF], + [0x4DF, 0x4DE], + [0x4E0, 0x4E1], + [0x4E1, 0x4E0], + [0x4E2, 0x4E3], + [0x4E3, 0x4E2], + [0x4E4, 0x4E5], + [0x4E5, 0x4E4], + [0x4E6, 0x4E7], + [0x4E7, 0x4E6], + [0x4E8, 0x4E9], + [0x4E9, 0x4E8], + [0x4EA, 0x4EB], + [0x4EB, 0x4EA], + [0x4EC, 0x4ED], + [0x4ED, 0x4EC], + [0x4EE, 0x4EF], + [0x4EF, 0x4EE], + [0x4F0, 0x4F1], + [0x4F1, 0x4F0], + [0x4F2, 0x4F3], + [0x4F3, 0x4F2], + [0x4F4, 0x4F5], + [0x4F5, 0x4F4], + [0x4F6, 0x4F7], + [0x4F7, 0x4F6], + [0x4F8, 0x4F9], + [0x4F9, 0x4F8], + [0x4FA, 0x4FB], + [0x4FB, 0x4FA], + [0x4FC, 0x4FD], + [0x4FD, 0x4FC], + [0x4FE, 0x4FF], + [0x4FF, 0x4FE], + [0x500, 0x501], + [0x501, 0x500], + [0x502, 0x503], + [0x503, 0x502], + [0x504, 0x505], + [0x505, 0x504], + [0x506, 0x507], + [0x507, 0x506], + [0x508, 0x509], + [0x509, 0x508], + [0x50A, 0x50B], + [0x50B, 0x50A], + [0x50C, 0x50D], + [0x50D, 0x50C], + [0x50E, 0x50F], + [0x50F, 0x50E], + [0x510, 0x511], + [0x511, 0x510], + [0x512, 0x513], + [0x513, 0x512], + [0x514, 0x515], + [0x515, 0x514], + [0x516, 0x517], + [0x517, 0x516], + [0x518, 0x519], + [0x519, 0x518], + [0x51A, 0x51B], + [0x51B, 0x51A], + [0x51C, 0x51D], + [0x51D, 0x51C], + [0x51E, 0x51F], + [0x51F, 0x51E], + [0x520, 0x521], + [0x521, 0x520], + [0x522, 0x523], + [0x523, 0x522], + [0x524, 0x525], + [0x525, 0x524], + [0x526, 0x527], + [0x527, 0x526], + [0x528, 0x529], + [0x529, 0x528], + [0x52A, 0x52B], + [0x52B, 0x52A], + [0x52C, 0x52D], + [0x52D, 0x52C], + [0x52E, 0x52F], + [0x52F, 0x52E], + [0x531, 0x561], + [0x532, 0x562], + [0x533, 0x563], + [0x534, 0x564], + [0x535, 0x565], + [0x536, 0x566], + [0x537, 0x567], + [0x538, 0x568], + [0x539, 0x569], + [0x53A, 0x56A], + [0x53B, 0x56B], + [0x53C, 0x56C], + [0x53D, 0x56D], + [0x53E, 0x56E], + [0x53F, 0x56F], + [0x540, 0x570], + [0x541, 0x571], + [0x542, 0x572], + [0x543, 0x573], + [0x544, 0x574], + [0x545, 0x575], + [0x546, 0x576], + [0x547, 0x577], + [0x548, 0x578], + [0x549, 0x579], + [0x54A, 0x57A], + [0x54B, 0x57B], + [0x54C, 0x57C], + [0x54D, 0x57D], + [0x54E, 0x57E], + [0x54F, 0x57F], + [0x550, 0x580], + [0x551, 0x581], + [0x552, 0x582], + [0x553, 0x583], + [0x554, 0x584], + [0x555, 0x585], + [0x556, 0x586], + [0x561, 0x531], + [0x562, 0x532], + [0x563, 0x533], + [0x564, 0x534], + [0x565, 0x535], + [0x566, 0x536], + [0x567, 0x537], + [0x568, 0x538], + [0x569, 0x539], + [0x56A, 0x53A], + [0x56B, 0x53B], + [0x56C, 0x53C], + [0x56D, 0x53D], + [0x56E, 0x53E], + [0x56F, 0x53F], + [0x570, 0x540], + [0x571, 0x541], + [0x572, 0x542], + [0x573, 0x543], + [0x574, 0x544], + [0x575, 0x545], + [0x576, 0x546], + [0x577, 0x547], + [0x578, 0x548], + [0x579, 0x549], + [0x57A, 0x54A], + [0x57B, 0x54B], + [0x57C, 0x54C], + [0x57D, 0x54D], + [0x57E, 0x54E], + [0x57F, 0x54F], + [0x580, 0x550], + [0x581, 0x551], + [0x582, 0x552], + [0x583, 0x553], + [0x584, 0x554], + [0x585, 0x555], + [0x586, 0x556], + [0x10A0, 0x2D00], + [0x10A1, 0x2D01], + [0x10A2, 0x2D02], + [0x10A3, 0x2D03], + [0x10A4, 0x2D04], + [0x10A5, 0x2D05], + [0x10A6, 0x2D06], + [0x10A7, 0x2D07], + [0x10A8, 0x2D08], + [0x10A9, 0x2D09], + [0x10AA, 0x2D0A], + [0x10AB, 0x2D0B], + [0x10AC, 0x2D0C], + [0x10AD, 0x2D0D], + [0x10AE, 0x2D0E], + [0x10AF, 0x2D0F], + [0x10B0, 0x2D10], + [0x10B1, 0x2D11], + [0x10B2, 0x2D12], + [0x10B3, 0x2D13], + [0x10B4, 0x2D14], + [0x10B5, 0x2D15], + [0x10B6, 0x2D16], + [0x10B7, 0x2D17], + [0x10B8, 0x2D18], + [0x10B9, 0x2D19], + [0x10BA, 0x2D1A], + [0x10BB, 0x2D1B], + [0x10BC, 0x2D1C], + [0x10BD, 0x2D1D], + [0x10BE, 0x2D1E], + [0x10BF, 0x2D1F], + [0x10C0, 0x2D20], + [0x10C1, 0x2D21], + [0x10C2, 0x2D22], + [0x10C3, 0x2D23], + [0x10C4, 0x2D24], + [0x10C5, 0x2D25], + [0x10C7, 0x2D27], + [0x10CD, 0x2D2D], + [0x10D0, 0x1C90], + [0x10D1, 0x1C91], + [0x10D2, 0x1C92], + [0x10D3, 0x1C93], + [0x10D4, 0x1C94], + [0x10D5, 0x1C95], + [0x10D6, 0x1C96], + [0x10D7, 0x1C97], + [0x10D8, 0x1C98], + [0x10D9, 0x1C99], + [0x10DA, 0x1C9A], + [0x10DB, 0x1C9B], + [0x10DC, 0x1C9C], + [0x10DD, 0x1C9D], + [0x10DE, 0x1C9E], + [0x10DF, 0x1C9F], + [0x10E0, 0x1CA0], + [0x10E1, 0x1CA1], + [0x10E2, 0x1CA2], + [0x10E3, 0x1CA3], + [0x10E4, 0x1CA4], + [0x10E5, 0x1CA5], + [0x10E6, 0x1CA6], + [0x10E7, 0x1CA7], + [0x10E8, 0x1CA8], + [0x10E9, 0x1CA9], + [0x10EA, 0x1CAA], + [0x10EB, 0x1CAB], + [0x10EC, 0x1CAC], + [0x10ED, 0x1CAD], + [0x10EE, 0x1CAE], + [0x10EF, 0x1CAF], + [0x10F0, 0x1CB0], + [0x10F1, 0x1CB1], + [0x10F2, 0x1CB2], + [0x10F3, 0x1CB3], + [0x10F4, 0x1CB4], + [0x10F5, 0x1CB5], + [0x10F6, 0x1CB6], + [0x10F7, 0x1CB7], + [0x10F8, 0x1CB8], + [0x10F9, 0x1CB9], + [0x10FA, 0x1CBA], + [0x10FD, 0x1CBD], + [0x10FE, 0x1CBE], + [0x10FF, 0x1CBF], + [0x13A0, 0xAB70], + [0x13A1, 0xAB71], + [0x13A2, 0xAB72], + [0x13A3, 0xAB73], + [0x13A4, 0xAB74], + [0x13A5, 0xAB75], + [0x13A6, 0xAB76], + [0x13A7, 0xAB77], + [0x13A8, 0xAB78], + [0x13A9, 0xAB79], + [0x13AA, 0xAB7A], + [0x13AB, 0xAB7B], + [0x13AC, 0xAB7C], + [0x13AD, 0xAB7D], + [0x13AE, 0xAB7E], + [0x13AF, 0xAB7F], + [0x13B0, 0xAB80], + [0x13B1, 0xAB81], + [0x13B2, 0xAB82], + [0x13B3, 0xAB83], + [0x13B4, 0xAB84], + [0x13B5, 0xAB85], + [0x13B6, 0xAB86], + [0x13B7, 0xAB87], + [0x13B8, 0xAB88], + [0x13B9, 0xAB89], + [0x13BA, 0xAB8A], + [0x13BB, 0xAB8B], + [0x13BC, 0xAB8C], + [0x13BD, 0xAB8D], + [0x13BE, 0xAB8E], + [0x13BF, 0xAB8F], + [0x13C0, 0xAB90], + [0x13C1, 0xAB91], + [0x13C2, 0xAB92], + [0x13C3, 0xAB93], + [0x13C4, 0xAB94], + [0x13C5, 0xAB95], + [0x13C6, 0xAB96], + [0x13C7, 0xAB97], + [0x13C8, 0xAB98], + [0x13C9, 0xAB99], + [0x13CA, 0xAB9A], + [0x13CB, 0xAB9B], + [0x13CC, 0xAB9C], + [0x13CD, 0xAB9D], + [0x13CE, 0xAB9E], + [0x13CF, 0xAB9F], + [0x13D0, 0xABA0], + [0x13D1, 0xABA1], + [0x13D2, 0xABA2], + [0x13D3, 0xABA3], + [0x13D4, 0xABA4], + [0x13D5, 0xABA5], + [0x13D6, 0xABA6], + [0x13D7, 0xABA7], + [0x13D8, 0xABA8], + [0x13D9, 0xABA9], + [0x13DA, 0xABAA], + [0x13DB, 0xABAB], + [0x13DC, 0xABAC], + [0x13DD, 0xABAD], + [0x13DE, 0xABAE], + [0x13DF, 0xABAF], + [0x13E0, 0xABB0], + [0x13E1, 0xABB1], + [0x13E2, 0xABB2], + [0x13E3, 0xABB3], + [0x13E4, 0xABB4], + [0x13E5, 0xABB5], + [0x13E6, 0xABB6], + [0x13E7, 0xABB7], + [0x13E8, 0xABB8], + [0x13E9, 0xABB9], + [0x13EA, 0xABBA], + [0x13EB, 0xABBB], + [0x13EC, 0xABBC], + [0x13ED, 0xABBD], + [0x13EE, 0xABBE], + [0x13EF, 0xABBF], + [0x13F0, 0x13F8], + [0x13F1, 0x13F9], + [0x13F2, 0x13FA], + [0x13F3, 0x13FB], + [0x13F4, 0x13FC], + [0x13F5, 0x13FD], + [0x13F8, 0x13F0], + [0x13F9, 0x13F1], + [0x13FA, 0x13F2], + [0x13FB, 0x13F3], + [0x13FC, 0x13F4], + [0x13FD, 0x13F5], + [0x1C80, 0x432], + [0x1C81, 0x434], + [0x1C82, 0x43E], + [0x1C83, 0x441], + [0x1C84, 0x442], + [0x1C85, 0x442], + [0x1C86, 0x44A], + [0x1C87, 0x463], + [0x1C88, 0xA64B], + [0x1C89, 0x1C8A], + [0x1C8A, 0x1C89], + [0x1C90, 0x10D0], + [0x1C91, 0x10D1], + [0x1C92, 0x10D2], + [0x1C93, 0x10D3], + [0x1C94, 0x10D4], + [0x1C95, 0x10D5], + [0x1C96, 0x10D6], + [0x1C97, 0x10D7], + [0x1C98, 0x10D8], + [0x1C99, 0x10D9], + [0x1C9A, 0x10DA], + [0x1C9B, 0x10DB], + [0x1C9C, 0x10DC], + [0x1C9D, 0x10DD], + [0x1C9E, 0x10DE], + [0x1C9F, 0x10DF], + [0x1CA0, 0x10E0], + [0x1CA1, 0x10E1], + [0x1CA2, 0x10E2], + [0x1CA3, 0x10E3], + [0x1CA4, 0x10E4], + [0x1CA5, 0x10E5], + [0x1CA6, 0x10E6], + [0x1CA7, 0x10E7], + [0x1CA8, 0x10E8], + [0x1CA9, 0x10E9], + [0x1CAA, 0x10EA], + [0x1CAB, 0x10EB], + [0x1CAC, 0x10EC], + [0x1CAD, 0x10ED], + [0x1CAE, 0x10EE], + [0x1CAF, 0x10EF], + [0x1CB0, 0x10F0], + [0x1CB1, 0x10F1], + [0x1CB2, 0x10F2], + [0x1CB3, 0x10F3], + [0x1CB4, 0x10F4], + [0x1CB5, 0x10F5], + [0x1CB6, 0x10F6], + [0x1CB7, 0x10F7], + [0x1CB8, 0x10F8], + [0x1CB9, 0x10F9], + [0x1CBA, 0x10FA], + [0x1CBD, 0x10FD], + [0x1CBE, 0x10FE], + [0x1CBF, 0x10FF], + [0x1D79, 0xA77D], + [0x1D7D, 0x2C63], + [0x1D8E, 0xA7C6], + [0x1E00, 0x1E01], + [0x1E01, 0x1E00], + [0x1E02, 0x1E03], + [0x1E03, 0x1E02], + [0x1E04, 0x1E05], + [0x1E05, 0x1E04], + [0x1E06, 0x1E07], + [0x1E07, 0x1E06], + [0x1E08, 0x1E09], + [0x1E09, 0x1E08], + [0x1E0A, 0x1E0B], + [0x1E0B, 0x1E0A], + [0x1E0C, 0x1E0D], + [0x1E0D, 0x1E0C], + [0x1E0E, 0x1E0F], + [0x1E0F, 0x1E0E], + [0x1E10, 0x1E11], + [0x1E11, 0x1E10], + [0x1E12, 0x1E13], + [0x1E13, 0x1E12], + [0x1E14, 0x1E15], + [0x1E15, 0x1E14], + [0x1E16, 0x1E17], + [0x1E17, 0x1E16], + [0x1E18, 0x1E19], + [0x1E19, 0x1E18], + [0x1E1A, 0x1E1B], + [0x1E1B, 0x1E1A], + [0x1E1C, 0x1E1D], + [0x1E1D, 0x1E1C], + [0x1E1E, 0x1E1F], + [0x1E1F, 0x1E1E], + [0x1E20, 0x1E21], + [0x1E21, 0x1E20], + [0x1E22, 0x1E23], + [0x1E23, 0x1E22], + [0x1E24, 0x1E25], + [0x1E25, 0x1E24], + [0x1E26, 0x1E27], + [0x1E27, 0x1E26], + [0x1E28, 0x1E29], + [0x1E29, 0x1E28], + [0x1E2A, 0x1E2B], + [0x1E2B, 0x1E2A], + [0x1E2C, 0x1E2D], + [0x1E2D, 0x1E2C], + [0x1E2E, 0x1E2F], + [0x1E2F, 0x1E2E], + [0x1E30, 0x1E31], + [0x1E31, 0x1E30], + [0x1E32, 0x1E33], + [0x1E33, 0x1E32], + [0x1E34, 0x1E35], + [0x1E35, 0x1E34], + [0x1E36, 0x1E37], + [0x1E37, 0x1E36], + [0x1E38, 0x1E39], + [0x1E39, 0x1E38], + [0x1E3A, 0x1E3B], + [0x1E3B, 0x1E3A], + [0x1E3C, 0x1E3D], + [0x1E3D, 0x1E3C], + [0x1E3E, 0x1E3F], + [0x1E3F, 0x1E3E], + [0x1E40, 0x1E41], + [0x1E41, 0x1E40], + [0x1E42, 0x1E43], + [0x1E43, 0x1E42], + [0x1E44, 0x1E45], + [0x1E45, 0x1E44], + [0x1E46, 0x1E47], + [0x1E47, 0x1E46], + [0x1E48, 0x1E49], + [0x1E49, 0x1E48], + [0x1E4A, 0x1E4B], + [0x1E4B, 0x1E4A], + [0x1E4C, 0x1E4D], + [0x1E4D, 0x1E4C], + [0x1E4E, 0x1E4F], + [0x1E4F, 0x1E4E], + [0x1E50, 0x1E51], + [0x1E51, 0x1E50], + [0x1E52, 0x1E53], + [0x1E53, 0x1E52], + [0x1E54, 0x1E55], + [0x1E55, 0x1E54], + [0x1E56, 0x1E57], + [0x1E57, 0x1E56], + [0x1E58, 0x1E59], + [0x1E59, 0x1E58], + [0x1E5A, 0x1E5B], + [0x1E5B, 0x1E5A], + [0x1E5C, 0x1E5D], + [0x1E5D, 0x1E5C], + [0x1E5E, 0x1E5F], + [0x1E5F, 0x1E5E], + [0x1E60, 0x1E61], + [0x1E61, [ + 0x1E60, + 0x1E9B + ]], + [0x1E62, 0x1E63], + [0x1E63, 0x1E62], + [0x1E64, 0x1E65], + [0x1E65, 0x1E64], + [0x1E66, 0x1E67], + [0x1E67, 0x1E66], + [0x1E68, 0x1E69], + [0x1E69, 0x1E68], + [0x1E6A, 0x1E6B], + [0x1E6B, 0x1E6A], + [0x1E6C, 0x1E6D], + [0x1E6D, 0x1E6C], + [0x1E6E, 0x1E6F], + [0x1E6F, 0x1E6E], + [0x1E70, 0x1E71], + [0x1E71, 0x1E70], + [0x1E72, 0x1E73], + [0x1E73, 0x1E72], + [0x1E74, 0x1E75], + [0x1E75, 0x1E74], + [0x1E76, 0x1E77], + [0x1E77, 0x1E76], + [0x1E78, 0x1E79], + [0x1E79, 0x1E78], + [0x1E7A, 0x1E7B], + [0x1E7B, 0x1E7A], + [0x1E7C, 0x1E7D], + [0x1E7D, 0x1E7C], + [0x1E7E, 0x1E7F], + [0x1E7F, 0x1E7E], + [0x1E80, 0x1E81], + [0x1E81, 0x1E80], + [0x1E82, 0x1E83], + [0x1E83, 0x1E82], + [0x1E84, 0x1E85], + [0x1E85, 0x1E84], + [0x1E86, 0x1E87], + [0x1E87, 0x1E86], + [0x1E88, 0x1E89], + [0x1E89, 0x1E88], + [0x1E8A, 0x1E8B], + [0x1E8B, 0x1E8A], + [0x1E8C, 0x1E8D], + [0x1E8D, 0x1E8C], + [0x1E8E, 0x1E8F], + [0x1E8F, 0x1E8E], + [0x1E90, 0x1E91], + [0x1E91, 0x1E90], + [0x1E92, 0x1E93], + [0x1E93, 0x1E92], + [0x1E94, 0x1E95], + [0x1E95, 0x1E94], + [0x1E9B, 0x1E61], + [0x1EA0, 0x1EA1], + [0x1EA1, 0x1EA0], + [0x1EA2, 0x1EA3], + [0x1EA3, 0x1EA2], + [0x1EA4, 0x1EA5], + [0x1EA5, 0x1EA4], + [0x1EA6, 0x1EA7], + [0x1EA7, 0x1EA6], + [0x1EA8, 0x1EA9], + [0x1EA9, 0x1EA8], + [0x1EAA, 0x1EAB], + [0x1EAB, 0x1EAA], + [0x1EAC, 0x1EAD], + [0x1EAD, 0x1EAC], + [0x1EAE, 0x1EAF], + [0x1EAF, 0x1EAE], + [0x1EB0, 0x1EB1], + [0x1EB1, 0x1EB0], + [0x1EB2, 0x1EB3], + [0x1EB3, 0x1EB2], + [0x1EB4, 0x1EB5], + [0x1EB5, 0x1EB4], + [0x1EB6, 0x1EB7], + [0x1EB7, 0x1EB6], + [0x1EB8, 0x1EB9], + [0x1EB9, 0x1EB8], + [0x1EBA, 0x1EBB], + [0x1EBB, 0x1EBA], + [0x1EBC, 0x1EBD], + [0x1EBD, 0x1EBC], + [0x1EBE, 0x1EBF], + [0x1EBF, 0x1EBE], + [0x1EC0, 0x1EC1], + [0x1EC1, 0x1EC0], + [0x1EC2, 0x1EC3], + [0x1EC3, 0x1EC2], + [0x1EC4, 0x1EC5], + [0x1EC5, 0x1EC4], + [0x1EC6, 0x1EC7], + [0x1EC7, 0x1EC6], + [0x1EC8, 0x1EC9], + [0x1EC9, 0x1EC8], + [0x1ECA, 0x1ECB], + [0x1ECB, 0x1ECA], + [0x1ECC, 0x1ECD], + [0x1ECD, 0x1ECC], + [0x1ECE, 0x1ECF], + [0x1ECF, 0x1ECE], + [0x1ED0, 0x1ED1], + [0x1ED1, 0x1ED0], + [0x1ED2, 0x1ED3], + [0x1ED3, 0x1ED2], + [0x1ED4, 0x1ED5], + [0x1ED5, 0x1ED4], + [0x1ED6, 0x1ED7], + [0x1ED7, 0x1ED6], + [0x1ED8, 0x1ED9], + [0x1ED9, 0x1ED8], + [0x1EDA, 0x1EDB], + [0x1EDB, 0x1EDA], + [0x1EDC, 0x1EDD], + [0x1EDD, 0x1EDC], + [0x1EDE, 0x1EDF], + [0x1EDF, 0x1EDE], + [0x1EE0, 0x1EE1], + [0x1EE1, 0x1EE0], + [0x1EE2, 0x1EE3], + [0x1EE3, 0x1EE2], + [0x1EE4, 0x1EE5], + [0x1EE5, 0x1EE4], + [0x1EE6, 0x1EE7], + [0x1EE7, 0x1EE6], + [0x1EE8, 0x1EE9], + [0x1EE9, 0x1EE8], + [0x1EEA, 0x1EEB], + [0x1EEB, 0x1EEA], + [0x1EEC, 0x1EED], + [0x1EED, 0x1EEC], + [0x1EEE, 0x1EEF], + [0x1EEF, 0x1EEE], + [0x1EF0, 0x1EF1], + [0x1EF1, 0x1EF0], + [0x1EF2, 0x1EF3], + [0x1EF3, 0x1EF2], + [0x1EF4, 0x1EF5], + [0x1EF5, 0x1EF4], + [0x1EF6, 0x1EF7], + [0x1EF7, 0x1EF6], + [0x1EF8, 0x1EF9], + [0x1EF9, 0x1EF8], + [0x1EFA, 0x1EFB], + [0x1EFB, 0x1EFA], + [0x1EFC, 0x1EFD], + [0x1EFD, 0x1EFC], + [0x1EFE, 0x1EFF], + [0x1EFF, 0x1EFE], + [0x1F00, 0x1F08], + [0x1F01, 0x1F09], + [0x1F02, 0x1F0A], + [0x1F03, 0x1F0B], + [0x1F04, 0x1F0C], + [0x1F05, 0x1F0D], + [0x1F06, 0x1F0E], + [0x1F07, 0x1F0F], + [0x1F08, 0x1F00], + [0x1F09, 0x1F01], + [0x1F0A, 0x1F02], + [0x1F0B, 0x1F03], + [0x1F0C, 0x1F04], + [0x1F0D, 0x1F05], + [0x1F0E, 0x1F06], + [0x1F0F, 0x1F07], + [0x1F10, 0x1F18], + [0x1F11, 0x1F19], + [0x1F12, 0x1F1A], + [0x1F13, 0x1F1B], + [0x1F14, 0x1F1C], + [0x1F15, 0x1F1D], + [0x1F18, 0x1F10], + [0x1F19, 0x1F11], + [0x1F1A, 0x1F12], + [0x1F1B, 0x1F13], + [0x1F1C, 0x1F14], + [0x1F1D, 0x1F15], + [0x1F20, 0x1F28], + [0x1F21, 0x1F29], + [0x1F22, 0x1F2A], + [0x1F23, 0x1F2B], + [0x1F24, 0x1F2C], + [0x1F25, 0x1F2D], + [0x1F26, 0x1F2E], + [0x1F27, 0x1F2F], + [0x1F28, 0x1F20], + [0x1F29, 0x1F21], + [0x1F2A, 0x1F22], + [0x1F2B, 0x1F23], + [0x1F2C, 0x1F24], + [0x1F2D, 0x1F25], + [0x1F2E, 0x1F26], + [0x1F2F, 0x1F27], + [0x1F30, 0x1F38], + [0x1F31, 0x1F39], + [0x1F32, 0x1F3A], + [0x1F33, 0x1F3B], + [0x1F34, 0x1F3C], + [0x1F35, 0x1F3D], + [0x1F36, 0x1F3E], + [0x1F37, 0x1F3F], + [0x1F38, 0x1F30], + [0x1F39, 0x1F31], + [0x1F3A, 0x1F32], + [0x1F3B, 0x1F33], + [0x1F3C, 0x1F34], + [0x1F3D, 0x1F35], + [0x1F3E, 0x1F36], + [0x1F3F, 0x1F37], + [0x1F40, 0x1F48], + [0x1F41, 0x1F49], + [0x1F42, 0x1F4A], + [0x1F43, 0x1F4B], + [0x1F44, 0x1F4C], + [0x1F45, 0x1F4D], + [0x1F48, 0x1F40], + [0x1F49, 0x1F41], + [0x1F4A, 0x1F42], + [0x1F4B, 0x1F43], + [0x1F4C, 0x1F44], + [0x1F4D, 0x1F45], + [0x1F51, 0x1F59], + [0x1F53, 0x1F5B], + [0x1F55, 0x1F5D], + [0x1F57, 0x1F5F], + [0x1F59, 0x1F51], + [0x1F5B, 0x1F53], + [0x1F5D, 0x1F55], + [0x1F5F, 0x1F57], + [0x1F60, 0x1F68], + [0x1F61, 0x1F69], + [0x1F62, 0x1F6A], + [0x1F63, 0x1F6B], + [0x1F64, 0x1F6C], + [0x1F65, 0x1F6D], + [0x1F66, 0x1F6E], + [0x1F67, 0x1F6F], + [0x1F68, 0x1F60], + [0x1F69, 0x1F61], + [0x1F6A, 0x1F62], + [0x1F6B, 0x1F63], + [0x1F6C, 0x1F64], + [0x1F6D, 0x1F65], + [0x1F6E, 0x1F66], + [0x1F6F, 0x1F67], + [0x1F70, 0x1FBA], + [0x1F71, 0x1FBB], + [0x1F72, 0x1FC8], + [0x1F73, 0x1FC9], + [0x1F74, 0x1FCA], + [0x1F75, 0x1FCB], + [0x1F76, 0x1FDA], + [0x1F77, 0x1FDB], + [0x1F78, 0x1FF8], + [0x1F79, 0x1FF9], + [0x1F7A, 0x1FEA], + [0x1F7B, 0x1FEB], + [0x1F7C, 0x1FFA], + [0x1F7D, 0x1FFB], + [0x1FB0, 0x1FB8], + [0x1FB1, 0x1FB9], + [0x1FB8, 0x1FB0], + [0x1FB9, 0x1FB1], + [0x1FBA, 0x1F70], + [0x1FBB, 0x1F71], + [0x1FBE, 0x3B9], + [0x1FC8, 0x1F72], + [0x1FC9, 0x1F73], + [0x1FCA, 0x1F74], + [0x1FCB, 0x1F75], + [0x1FD0, 0x1FD8], + [0x1FD1, 0x1FD9], + [0x1FD8, 0x1FD0], + [0x1FD9, 0x1FD1], + [0x1FDA, 0x1F76], + [0x1FDB, 0x1F77], + [0x1FE0, 0x1FE8], + [0x1FE1, 0x1FE9], + [0x1FE5, 0x1FEC], + [0x1FE8, 0x1FE0], + [0x1FE9, 0x1FE1], + [0x1FEA, 0x1F7A], + [0x1FEB, 0x1F7B], + [0x1FEC, 0x1FE5], + [0x1FF8, 0x1F78], + [0x1FF9, 0x1F79], + [0x1FFA, 0x1F7C], + [0x1FFB, 0x1F7D], + [0x2132, 0x214E], + [0x214E, 0x2132], + [0x2160, 0x2170], + [0x2161, 0x2171], + [0x2162, 0x2172], + [0x2163, 0x2173], + [0x2164, 0x2174], + [0x2165, 0x2175], + [0x2166, 0x2176], + [0x2167, 0x2177], + [0x2168, 0x2178], + [0x2169, 0x2179], + [0x216A, 0x217A], + [0x216B, 0x217B], + [0x216C, 0x217C], + [0x216D, 0x217D], + [0x216E, 0x217E], + [0x216F, 0x217F], + [0x2170, 0x2160], + [0x2171, 0x2161], + [0x2172, 0x2162], + [0x2173, 0x2163], + [0x2174, 0x2164], + [0x2175, 0x2165], + [0x2176, 0x2166], + [0x2177, 0x2167], + [0x2178, 0x2168], + [0x2179, 0x2169], + [0x217A, 0x216A], + [0x217B, 0x216B], + [0x217C, 0x216C], + [0x217D, 0x216D], + [0x217E, 0x216E], + [0x217F, 0x216F], + [0x2183, 0x2184], + [0x2184, 0x2183], + [0x24B6, 0x24D0], + [0x24B7, 0x24D1], + [0x24B8, 0x24D2], + [0x24B9, 0x24D3], + [0x24BA, 0x24D4], + [0x24BB, 0x24D5], + [0x24BC, 0x24D6], + [0x24BD, 0x24D7], + [0x24BE, 0x24D8], + [0x24BF, 0x24D9], + [0x24C0, 0x24DA], + [0x24C1, 0x24DB], + [0x24C2, 0x24DC], + [0x24C3, 0x24DD], + [0x24C4, 0x24DE], + [0x24C5, 0x24DF], + [0x24C6, 0x24E0], + [0x24C7, 0x24E1], + [0x24C8, 0x24E2], + [0x24C9, 0x24E3], + [0x24CA, 0x24E4], + [0x24CB, 0x24E5], + [0x24CC, 0x24E6], + [0x24CD, 0x24E7], + [0x24CE, 0x24E8], + [0x24CF, 0x24E9], + [0x24D0, 0x24B6], + [0x24D1, 0x24B7], + [0x24D2, 0x24B8], + [0x24D3, 0x24B9], + [0x24D4, 0x24BA], + [0x24D5, 0x24BB], + [0x24D6, 0x24BC], + [0x24D7, 0x24BD], + [0x24D8, 0x24BE], + [0x24D9, 0x24BF], + [0x24DA, 0x24C0], + [0x24DB, 0x24C1], + [0x24DC, 0x24C2], + [0x24DD, 0x24C3], + [0x24DE, 0x24C4], + [0x24DF, 0x24C5], + [0x24E0, 0x24C6], + [0x24E1, 0x24C7], + [0x24E2, 0x24C8], + [0x24E3, 0x24C9], + [0x24E4, 0x24CA], + [0x24E5, 0x24CB], + [0x24E6, 0x24CC], + [0x24E7, 0x24CD], + [0x24E8, 0x24CE], + [0x24E9, 0x24CF], + [0x2C00, 0x2C30], + [0x2C01, 0x2C31], + [0x2C02, 0x2C32], + [0x2C03, 0x2C33], + [0x2C04, 0x2C34], + [0x2C05, 0x2C35], + [0x2C06, 0x2C36], + [0x2C07, 0x2C37], + [0x2C08, 0x2C38], + [0x2C09, 0x2C39], + [0x2C0A, 0x2C3A], + [0x2C0B, 0x2C3B], + [0x2C0C, 0x2C3C], + [0x2C0D, 0x2C3D], + [0x2C0E, 0x2C3E], + [0x2C0F, 0x2C3F], + [0x2C10, 0x2C40], + [0x2C11, 0x2C41], + [0x2C12, 0x2C42], + [0x2C13, 0x2C43], + [0x2C14, 0x2C44], + [0x2C15, 0x2C45], + [0x2C16, 0x2C46], + [0x2C17, 0x2C47], + [0x2C18, 0x2C48], + [0x2C19, 0x2C49], + [0x2C1A, 0x2C4A], + [0x2C1B, 0x2C4B], + [0x2C1C, 0x2C4C], + [0x2C1D, 0x2C4D], + [0x2C1E, 0x2C4E], + [0x2C1F, 0x2C4F], + [0x2C20, 0x2C50], + [0x2C21, 0x2C51], + [0x2C22, 0x2C52], + [0x2C23, 0x2C53], + [0x2C24, 0x2C54], + [0x2C25, 0x2C55], + [0x2C26, 0x2C56], + [0x2C27, 0x2C57], + [0x2C28, 0x2C58], + [0x2C29, 0x2C59], + [0x2C2A, 0x2C5A], + [0x2C2B, 0x2C5B], + [0x2C2C, 0x2C5C], + [0x2C2D, 0x2C5D], + [0x2C2E, 0x2C5E], + [0x2C2F, 0x2C5F], + [0x2C30, 0x2C00], + [0x2C31, 0x2C01], + [0x2C32, 0x2C02], + [0x2C33, 0x2C03], + [0x2C34, 0x2C04], + [0x2C35, 0x2C05], + [0x2C36, 0x2C06], + [0x2C37, 0x2C07], + [0x2C38, 0x2C08], + [0x2C39, 0x2C09], + [0x2C3A, 0x2C0A], + [0x2C3B, 0x2C0B], + [0x2C3C, 0x2C0C], + [0x2C3D, 0x2C0D], + [0x2C3E, 0x2C0E], + [0x2C3F, 0x2C0F], + [0x2C40, 0x2C10], + [0x2C41, 0x2C11], + [0x2C42, 0x2C12], + [0x2C43, 0x2C13], + [0x2C44, 0x2C14], + [0x2C45, 0x2C15], + [0x2C46, 0x2C16], + [0x2C47, 0x2C17], + [0x2C48, 0x2C18], + [0x2C49, 0x2C19], + [0x2C4A, 0x2C1A], + [0x2C4B, 0x2C1B], + [0x2C4C, 0x2C1C], + [0x2C4D, 0x2C1D], + [0x2C4E, 0x2C1E], + [0x2C4F, 0x2C1F], + [0x2C50, 0x2C20], + [0x2C51, 0x2C21], + [0x2C52, 0x2C22], + [0x2C53, 0x2C23], + [0x2C54, 0x2C24], + [0x2C55, 0x2C25], + [0x2C56, 0x2C26], + [0x2C57, 0x2C27], + [0x2C58, 0x2C28], + [0x2C59, 0x2C29], + [0x2C5A, 0x2C2A], + [0x2C5B, 0x2C2B], + [0x2C5C, 0x2C2C], + [0x2C5D, 0x2C2D], + [0x2C5E, 0x2C2E], + [0x2C5F, 0x2C2F], + [0x2C60, 0x2C61], + [0x2C61, 0x2C60], + [0x2C62, 0x26B], + [0x2C63, 0x1D7D], + [0x2C64, 0x27D], + [0x2C65, 0x23A], + [0x2C66, 0x23E], + [0x2C67, 0x2C68], + [0x2C68, 0x2C67], + [0x2C69, 0x2C6A], + [0x2C6A, 0x2C69], + [0x2C6B, 0x2C6C], + [0x2C6C, 0x2C6B], + [0x2C6D, 0x251], + [0x2C6E, 0x271], + [0x2C6F, 0x250], + [0x2C70, 0x252], + [0x2C72, 0x2C73], + [0x2C73, 0x2C72], + [0x2C75, 0x2C76], + [0x2C76, 0x2C75], + [0x2C7E, 0x23F], + [0x2C7F, 0x240], + [0x2C80, 0x2C81], + [0x2C81, 0x2C80], + [0x2C82, 0x2C83], + [0x2C83, 0x2C82], + [0x2C84, 0x2C85], + [0x2C85, 0x2C84], + [0x2C86, 0x2C87], + [0x2C87, 0x2C86], + [0x2C88, 0x2C89], + [0x2C89, 0x2C88], + [0x2C8A, 0x2C8B], + [0x2C8B, 0x2C8A], + [0x2C8C, 0x2C8D], + [0x2C8D, 0x2C8C], + [0x2C8E, 0x2C8F], + [0x2C8F, 0x2C8E], + [0x2C90, 0x2C91], + [0x2C91, 0x2C90], + [0x2C92, 0x2C93], + [0x2C93, 0x2C92], + [0x2C94, 0x2C95], + [0x2C95, 0x2C94], + [0x2C96, 0x2C97], + [0x2C97, 0x2C96], + [0x2C98, 0x2C99], + [0x2C99, 0x2C98], + [0x2C9A, 0x2C9B], + [0x2C9B, 0x2C9A], + [0x2C9C, 0x2C9D], + [0x2C9D, 0x2C9C], + [0x2C9E, 0x2C9F], + [0x2C9F, 0x2C9E], + [0x2CA0, 0x2CA1], + [0x2CA1, 0x2CA0], + [0x2CA2, 0x2CA3], + [0x2CA3, 0x2CA2], + [0x2CA4, 0x2CA5], + [0x2CA5, 0x2CA4], + [0x2CA6, 0x2CA7], + [0x2CA7, 0x2CA6], + [0x2CA8, 0x2CA9], + [0x2CA9, 0x2CA8], + [0x2CAA, 0x2CAB], + [0x2CAB, 0x2CAA], + [0x2CAC, 0x2CAD], + [0x2CAD, 0x2CAC], + [0x2CAE, 0x2CAF], + [0x2CAF, 0x2CAE], + [0x2CB0, 0x2CB1], + [0x2CB1, 0x2CB0], + [0x2CB2, 0x2CB3], + [0x2CB3, 0x2CB2], + [0x2CB4, 0x2CB5], + [0x2CB5, 0x2CB4], + [0x2CB6, 0x2CB7], + [0x2CB7, 0x2CB6], + [0x2CB8, 0x2CB9], + [0x2CB9, 0x2CB8], + [0x2CBA, 0x2CBB], + [0x2CBB, 0x2CBA], + [0x2CBC, 0x2CBD], + [0x2CBD, 0x2CBC], + [0x2CBE, 0x2CBF], + [0x2CBF, 0x2CBE], + [0x2CC0, 0x2CC1], + [0x2CC1, 0x2CC0], + [0x2CC2, 0x2CC3], + [0x2CC3, 0x2CC2], + [0x2CC4, 0x2CC5], + [0x2CC5, 0x2CC4], + [0x2CC6, 0x2CC7], + [0x2CC7, 0x2CC6], + [0x2CC8, 0x2CC9], + [0x2CC9, 0x2CC8], + [0x2CCA, 0x2CCB], + [0x2CCB, 0x2CCA], + [0x2CCC, 0x2CCD], + [0x2CCD, 0x2CCC], + [0x2CCE, 0x2CCF], + [0x2CCF, 0x2CCE], + [0x2CD0, 0x2CD1], + [0x2CD1, 0x2CD0], + [0x2CD2, 0x2CD3], + [0x2CD3, 0x2CD2], + [0x2CD4, 0x2CD5], + [0x2CD5, 0x2CD4], + [0x2CD6, 0x2CD7], + [0x2CD7, 0x2CD6], + [0x2CD8, 0x2CD9], + [0x2CD9, 0x2CD8], + [0x2CDA, 0x2CDB], + [0x2CDB, 0x2CDA], + [0x2CDC, 0x2CDD], + [0x2CDD, 0x2CDC], + [0x2CDE, 0x2CDF], + [0x2CDF, 0x2CDE], + [0x2CE0, 0x2CE1], + [0x2CE1, 0x2CE0], + [0x2CE2, 0x2CE3], + [0x2CE3, 0x2CE2], + [0x2CEB, 0x2CEC], + [0x2CEC, 0x2CEB], + [0x2CED, 0x2CEE], + [0x2CEE, 0x2CED], + [0x2CF2, 0x2CF3], + [0x2CF3, 0x2CF2], + [0x2D00, 0x10A0], + [0x2D01, 0x10A1], + [0x2D02, 0x10A2], + [0x2D03, 0x10A3], + [0x2D04, 0x10A4], + [0x2D05, 0x10A5], + [0x2D06, 0x10A6], + [0x2D07, 0x10A7], + [0x2D08, 0x10A8], + [0x2D09, 0x10A9], + [0x2D0A, 0x10AA], + [0x2D0B, 0x10AB], + [0x2D0C, 0x10AC], + [0x2D0D, 0x10AD], + [0x2D0E, 0x10AE], + [0x2D0F, 0x10AF], + [0x2D10, 0x10B0], + [0x2D11, 0x10B1], + [0x2D12, 0x10B2], + [0x2D13, 0x10B3], + [0x2D14, 0x10B4], + [0x2D15, 0x10B5], + [0x2D16, 0x10B6], + [0x2D17, 0x10B7], + [0x2D18, 0x10B8], + [0x2D19, 0x10B9], + [0x2D1A, 0x10BA], + [0x2D1B, 0x10BB], + [0x2D1C, 0x10BC], + [0x2D1D, 0x10BD], + [0x2D1E, 0x10BE], + [0x2D1F, 0x10BF], + [0x2D20, 0x10C0], + [0x2D21, 0x10C1], + [0x2D22, 0x10C2], + [0x2D23, 0x10C3], + [0x2D24, 0x10C4], + [0x2D25, 0x10C5], + [0x2D27, 0x10C7], + [0x2D2D, 0x10CD], + [0xA640, 0xA641], + [0xA641, 0xA640], + [0xA642, 0xA643], + [0xA643, 0xA642], + [0xA644, 0xA645], + [0xA645, 0xA644], + [0xA646, 0xA647], + [0xA647, 0xA646], + [0xA648, 0xA649], + [0xA649, 0xA648], + [0xA64A, 0xA64B], + [0xA64B, [ + 0x1C88, + 0xA64A + ]], + [0xA64C, 0xA64D], + [0xA64D, 0xA64C], + [0xA64E, 0xA64F], + [0xA64F, 0xA64E], + [0xA650, 0xA651], + [0xA651, 0xA650], + [0xA652, 0xA653], + [0xA653, 0xA652], + [0xA654, 0xA655], + [0xA655, 0xA654], + [0xA656, 0xA657], + [0xA657, 0xA656], + [0xA658, 0xA659], + [0xA659, 0xA658], + [0xA65A, 0xA65B], + [0xA65B, 0xA65A], + [0xA65C, 0xA65D], + [0xA65D, 0xA65C], + [0xA65E, 0xA65F], + [0xA65F, 0xA65E], + [0xA660, 0xA661], + [0xA661, 0xA660], + [0xA662, 0xA663], + [0xA663, 0xA662], + [0xA664, 0xA665], + [0xA665, 0xA664], + [0xA666, 0xA667], + [0xA667, 0xA666], + [0xA668, 0xA669], + [0xA669, 0xA668], + [0xA66A, 0xA66B], + [0xA66B, 0xA66A], + [0xA66C, 0xA66D], + [0xA66D, 0xA66C], + [0xA680, 0xA681], + [0xA681, 0xA680], + [0xA682, 0xA683], + [0xA683, 0xA682], + [0xA684, 0xA685], + [0xA685, 0xA684], + [0xA686, 0xA687], + [0xA687, 0xA686], + [0xA688, 0xA689], + [0xA689, 0xA688], + [0xA68A, 0xA68B], + [0xA68B, 0xA68A], + [0xA68C, 0xA68D], + [0xA68D, 0xA68C], + [0xA68E, 0xA68F], + [0xA68F, 0xA68E], + [0xA690, 0xA691], + [0xA691, 0xA690], + [0xA692, 0xA693], + [0xA693, 0xA692], + [0xA694, 0xA695], + [0xA695, 0xA694], + [0xA696, 0xA697], + [0xA697, 0xA696], + [0xA698, 0xA699], + [0xA699, 0xA698], + [0xA69A, 0xA69B], + [0xA69B, 0xA69A], + [0xA722, 0xA723], + [0xA723, 0xA722], + [0xA724, 0xA725], + [0xA725, 0xA724], + [0xA726, 0xA727], + [0xA727, 0xA726], + [0xA728, 0xA729], + [0xA729, 0xA728], + [0xA72A, 0xA72B], + [0xA72B, 0xA72A], + [0xA72C, 0xA72D], + [0xA72D, 0xA72C], + [0xA72E, 0xA72F], + [0xA72F, 0xA72E], + [0xA732, 0xA733], + [0xA733, 0xA732], + [0xA734, 0xA735], + [0xA735, 0xA734], + [0xA736, 0xA737], + [0xA737, 0xA736], + [0xA738, 0xA739], + [0xA739, 0xA738], + [0xA73A, 0xA73B], + [0xA73B, 0xA73A], + [0xA73C, 0xA73D], + [0xA73D, 0xA73C], + [0xA73E, 0xA73F], + [0xA73F, 0xA73E], + [0xA740, 0xA741], + [0xA741, 0xA740], + [0xA742, 0xA743], + [0xA743, 0xA742], + [0xA744, 0xA745], + [0xA745, 0xA744], + [0xA746, 0xA747], + [0xA747, 0xA746], + [0xA748, 0xA749], + [0xA749, 0xA748], + [0xA74A, 0xA74B], + [0xA74B, 0xA74A], + [0xA74C, 0xA74D], + [0xA74D, 0xA74C], + [0xA74E, 0xA74F], + [0xA74F, 0xA74E], + [0xA750, 0xA751], + [0xA751, 0xA750], + [0xA752, 0xA753], + [0xA753, 0xA752], + [0xA754, 0xA755], + [0xA755, 0xA754], + [0xA756, 0xA757], + [0xA757, 0xA756], + [0xA758, 0xA759], + [0xA759, 0xA758], + [0xA75A, 0xA75B], + [0xA75B, 0xA75A], + [0xA75C, 0xA75D], + [0xA75D, 0xA75C], + [0xA75E, 0xA75F], + [0xA75F, 0xA75E], + [0xA760, 0xA761], + [0xA761, 0xA760], + [0xA762, 0xA763], + [0xA763, 0xA762], + [0xA764, 0xA765], + [0xA765, 0xA764], + [0xA766, 0xA767], + [0xA767, 0xA766], + [0xA768, 0xA769], + [0xA769, 0xA768], + [0xA76A, 0xA76B], + [0xA76B, 0xA76A], + [0xA76C, 0xA76D], + [0xA76D, 0xA76C], + [0xA76E, 0xA76F], + [0xA76F, 0xA76E], + [0xA779, 0xA77A], + [0xA77A, 0xA779], + [0xA77B, 0xA77C], + [0xA77C, 0xA77B], + [0xA77D, 0x1D79], + [0xA77E, 0xA77F], + [0xA77F, 0xA77E], + [0xA780, 0xA781], + [0xA781, 0xA780], + [0xA782, 0xA783], + [0xA783, 0xA782], + [0xA784, 0xA785], + [0xA785, 0xA784], + [0xA786, 0xA787], + [0xA787, 0xA786], + [0xA78B, 0xA78C], + [0xA78C, 0xA78B], + [0xA78D, 0x265], + [0xA790, 0xA791], + [0xA791, 0xA790], + [0xA792, 0xA793], + [0xA793, 0xA792], + [0xA794, 0xA7C4], + [0xA796, 0xA797], + [0xA797, 0xA796], + [0xA798, 0xA799], + [0xA799, 0xA798], + [0xA79A, 0xA79B], + [0xA79B, 0xA79A], + [0xA79C, 0xA79D], + [0xA79D, 0xA79C], + [0xA79E, 0xA79F], + [0xA79F, 0xA79E], + [0xA7A0, 0xA7A1], + [0xA7A1, 0xA7A0], + [0xA7A2, 0xA7A3], + [0xA7A3, 0xA7A2], + [0xA7A4, 0xA7A5], + [0xA7A5, 0xA7A4], + [0xA7A6, 0xA7A7], + [0xA7A7, 0xA7A6], + [0xA7A8, 0xA7A9], + [0xA7A9, 0xA7A8], + [0xA7AA, 0x266], + [0xA7AB, 0x25C], + [0xA7AC, 0x261], + [0xA7AD, 0x26C], + [0xA7AE, 0x26A], + [0xA7B0, 0x29E], + [0xA7B1, 0x287], + [0xA7B2, 0x29D], + [0xA7B3, 0xAB53], + [0xA7B4, 0xA7B5], + [0xA7B5, 0xA7B4], + [0xA7B6, 0xA7B7], + [0xA7B7, 0xA7B6], + [0xA7B8, 0xA7B9], + [0xA7B9, 0xA7B8], + [0xA7BA, 0xA7BB], + [0xA7BB, 0xA7BA], + [0xA7BC, 0xA7BD], + [0xA7BD, 0xA7BC], + [0xA7BE, 0xA7BF], + [0xA7BF, 0xA7BE], + [0xA7C0, 0xA7C1], + [0xA7C1, 0xA7C0], + [0xA7C2, 0xA7C3], + [0xA7C3, 0xA7C2], + [0xA7C4, 0xA794], + [0xA7C5, 0x282], + [0xA7C6, 0x1D8E], + [0xA7C7, 0xA7C8], + [0xA7C8, 0xA7C7], + [0xA7C9, 0xA7CA], + [0xA7CA, 0xA7C9], + [0xA7CB, 0x264], + [0xA7CC, 0xA7CD], + [0xA7CD, 0xA7CC], + [0xA7CE, 0xA7CF], + [0xA7CF, 0xA7CE], + [0xA7D0, 0xA7D1], + [0xA7D1, 0xA7D0], + [0xA7D2, 0xA7D3], + [0xA7D3, 0xA7D2], + [0xA7D4, 0xA7D5], + [0xA7D5, 0xA7D4], + [0xA7D6, 0xA7D7], + [0xA7D7, 0xA7D6], + [0xA7D8, 0xA7D9], + [0xA7D9, 0xA7D8], + [0xA7DA, 0xA7DB], + [0xA7DB, 0xA7DA], + [0xA7DC, 0x19B], + [0xA7F5, 0xA7F6], + [0xA7F6, 0xA7F5], + [0xAB53, 0xA7B3], + [0xAB70, 0x13A0], + [0xAB71, 0x13A1], + [0xAB72, 0x13A2], + [0xAB73, 0x13A3], + [0xAB74, 0x13A4], + [0xAB75, 0x13A5], + [0xAB76, 0x13A6], + [0xAB77, 0x13A7], + [0xAB78, 0x13A8], + [0xAB79, 0x13A9], + [0xAB7A, 0x13AA], + [0xAB7B, 0x13AB], + [0xAB7C, 0x13AC], + [0xAB7D, 0x13AD], + [0xAB7E, 0x13AE], + [0xAB7F, 0x13AF], + [0xAB80, 0x13B0], + [0xAB81, 0x13B1], + [0xAB82, 0x13B2], + [0xAB83, 0x13B3], + [0xAB84, 0x13B4], + [0xAB85, 0x13B5], + [0xAB86, 0x13B6], + [0xAB87, 0x13B7], + [0xAB88, 0x13B8], + [0xAB89, 0x13B9], + [0xAB8A, 0x13BA], + [0xAB8B, 0x13BB], + [0xAB8C, 0x13BC], + [0xAB8D, 0x13BD], + [0xAB8E, 0x13BE], + [0xAB8F, 0x13BF], + [0xAB90, 0x13C0], + [0xAB91, 0x13C1], + [0xAB92, 0x13C2], + [0xAB93, 0x13C3], + [0xAB94, 0x13C4], + [0xAB95, 0x13C5], + [0xAB96, 0x13C6], + [0xAB97, 0x13C7], + [0xAB98, 0x13C8], + [0xAB99, 0x13C9], + [0xAB9A, 0x13CA], + [0xAB9B, 0x13CB], + [0xAB9C, 0x13CC], + [0xAB9D, 0x13CD], + [0xAB9E, 0x13CE], + [0xAB9F, 0x13CF], + [0xABA0, 0x13D0], + [0xABA1, 0x13D1], + [0xABA2, 0x13D2], + [0xABA3, 0x13D3], + [0xABA4, 0x13D4], + [0xABA5, 0x13D5], + [0xABA6, 0x13D6], + [0xABA7, 0x13D7], + [0xABA8, 0x13D8], + [0xABA9, 0x13D9], + [0xABAA, 0x13DA], + [0xABAB, 0x13DB], + [0xABAC, 0x13DC], + [0xABAD, 0x13DD], + [0xABAE, 0x13DE], + [0xABAF, 0x13DF], + [0xABB0, 0x13E0], + [0xABB1, 0x13E1], + [0xABB2, 0x13E2], + [0xABB3, 0x13E3], + [0xABB4, 0x13E4], + [0xABB5, 0x13E5], + [0xABB6, 0x13E6], + [0xABB7, 0x13E7], + [0xABB8, 0x13E8], + [0xABB9, 0x13E9], + [0xABBA, 0x13EA], + [0xABBB, 0x13EB], + [0xABBC, 0x13EC], + [0xABBD, 0x13ED], + [0xABBE, 0x13EE], + [0xABBF, 0x13EF], + [0xFF21, 0xFF41], + [0xFF22, 0xFF42], + [0xFF23, 0xFF43], + [0xFF24, 0xFF44], + [0xFF25, 0xFF45], + [0xFF26, 0xFF46], + [0xFF27, 0xFF47], + [0xFF28, 0xFF48], + [0xFF29, 0xFF49], + [0xFF2A, 0xFF4A], + [0xFF2B, 0xFF4B], + [0xFF2C, 0xFF4C], + [0xFF2D, 0xFF4D], + [0xFF2E, 0xFF4E], + [0xFF2F, 0xFF4F], + [0xFF30, 0xFF50], + [0xFF31, 0xFF51], + [0xFF32, 0xFF52], + [0xFF33, 0xFF53], + [0xFF34, 0xFF54], + [0xFF35, 0xFF55], + [0xFF36, 0xFF56], + [0xFF37, 0xFF57], + [0xFF38, 0xFF58], + [0xFF39, 0xFF59], + [0xFF3A, 0xFF5A], + [0xFF41, 0xFF21], + [0xFF42, 0xFF22], + [0xFF43, 0xFF23], + [0xFF44, 0xFF24], + [0xFF45, 0xFF25], + [0xFF46, 0xFF26], + [0xFF47, 0xFF27], + [0xFF48, 0xFF28], + [0xFF49, 0xFF29], + [0xFF4A, 0xFF2A], + [0xFF4B, 0xFF2B], + [0xFF4C, 0xFF2C], + [0xFF4D, 0xFF2D], + [0xFF4E, 0xFF2E], + [0xFF4F, 0xFF2F], + [0xFF50, 0xFF30], + [0xFF51, 0xFF31], + [0xFF52, 0xFF32], + [0xFF53, 0xFF33], + [0xFF54, 0xFF34], + [0xFF55, 0xFF35], + [0xFF56, 0xFF36], + [0xFF57, 0xFF37], + [0xFF58, 0xFF38], + [0xFF59, 0xFF39], + [0xFF5A, 0xFF3A] +]); diff --git a/tools/ui/node_modules/regexpu-core/data/iu-foldings.js b/tools/ui/node_modules/regexpu-core/data/iu-foldings.js new file mode 100644 index 0000000000000000000000000000000000000000..21c97e91a57aa8f18f4f9fad35a639e00a45d291 --- /dev/null +++ b/tools/ui/node_modules/regexpu-core/data/iu-foldings.js @@ -0,0 +1,1514 @@ +module.exports = new Map([ + [0x41, 0x61], + [0x42, 0x62], + [0x43, 0x63], + [0x44, 0x64], + [0x45, 0x65], + [0x46, 0x66], + [0x47, 0x67], + [0x48, 0x68], + [0x49, 0x69], + [0x4A, 0x6A], + [0x4B, 0x6B], + [0x4C, 0x6C], + [0x4D, 0x6D], + [0x4E, 0x6E], + [0x4F, 0x6F], + [0x50, 0x70], + [0x51, 0x71], + [0x52, 0x72], + [0x53, 0x73], + [0x54, 0x74], + [0x55, 0x75], + [0x56, 0x76], + [0x57, 0x77], + [0x58, 0x78], + [0x59, 0x79], + [0x5A, 0x7A], + [0xB5, 0x3BC], + [0xC0, 0xE0], + [0xC1, 0xE1], + [0xC2, 0xE2], + [0xC3, 0xE3], + [0xC4, 0xE4], + [0xC5, 0xE5], + [0xC6, 0xE6], + [0xC7, 0xE7], + [0xC8, 0xE8], + [0xC9, 0xE9], + [0xCA, 0xEA], + [0xCB, 0xEB], + [0xCC, 0xEC], + [0xCD, 0xED], + [0xCE, 0xEE], + [0xCF, 0xEF], + [0xD0, 0xF0], + [0xD1, 0xF1], + [0xD2, 0xF2], + [0xD3, 0xF3], + [0xD4, 0xF4], + [0xD5, 0xF5], + [0xD6, 0xF6], + [0xD8, 0xF8], + [0xD9, 0xF9], + [0xDA, 0xFA], + [0xDB, 0xFB], + [0xDC, 0xFC], + [0xDD, 0xFD], + [0xDE, 0xFE], + [0x100, 0x101], + [0x102, 0x103], + [0x104, 0x105], + [0x106, 0x107], + [0x108, 0x109], + [0x10A, 0x10B], + [0x10C, 0x10D], + [0x10E, 0x10F], + [0x110, 0x111], + [0x112, 0x113], + [0x114, 0x115], + [0x116, 0x117], + [0x118, 0x119], + [0x11A, 0x11B], + [0x11C, 0x11D], + [0x11E, 0x11F], + [0x120, 0x121], + [0x122, 0x123], + [0x124, 0x125], + [0x126, 0x127], + [0x128, 0x129], + [0x12A, 0x12B], + [0x12C, 0x12D], + [0x12E, 0x12F], + [0x132, 0x133], + [0x134, 0x135], + [0x136, 0x137], + [0x139, 0x13A], + [0x13B, 0x13C], + [0x13D, 0x13E], + [0x13F, 0x140], + [0x141, 0x142], + [0x143, 0x144], + [0x145, 0x146], + [0x147, 0x148], + [0x14A, 0x14B], + [0x14C, 0x14D], + [0x14E, 0x14F], + [0x150, 0x151], + [0x152, 0x153], + [0x154, 0x155], + [0x156, 0x157], + [0x158, 0x159], + [0x15A, 0x15B], + [0x15C, 0x15D], + [0x15E, 0x15F], + [0x160, 0x161], + [0x162, 0x163], + [0x164, 0x165], + [0x166, 0x167], + [0x168, 0x169], + [0x16A, 0x16B], + [0x16C, 0x16D], + [0x16E, 0x16F], + [0x170, 0x171], + [0x172, 0x173], + [0x174, 0x175], + [0x176, 0x177], + [0x178, 0xFF], + [0x179, 0x17A], + [0x17B, 0x17C], + [0x17D, 0x17E], + [0x17F, 0x73], + [0x181, 0x253], + [0x182, 0x183], + [0x184, 0x185], + [0x186, 0x254], + [0x187, 0x188], + [0x189, 0x256], + [0x18A, 0x257], + [0x18B, 0x18C], + [0x18E, 0x1DD], + [0x18F, 0x259], + [0x190, 0x25B], + [0x191, 0x192], + [0x193, 0x260], + [0x194, 0x263], + [0x196, 0x269], + [0x197, 0x268], + [0x198, 0x199], + [0x19C, 0x26F], + [0x19D, 0x272], + [0x19F, 0x275], + [0x1A0, 0x1A1], + [0x1A2, 0x1A3], + [0x1A4, 0x1A5], + [0x1A6, 0x280], + [0x1A7, 0x1A8], + [0x1A9, 0x283], + [0x1AC, 0x1AD], + [0x1AE, 0x288], + [0x1AF, 0x1B0], + [0x1B1, 0x28A], + [0x1B2, 0x28B], + [0x1B3, 0x1B4], + [0x1B5, 0x1B6], + [0x1B7, 0x292], + [0x1B8, 0x1B9], + [0x1BC, 0x1BD], + [0x1C4, 0x1C6], + [0x1C5, 0x1C6], + [0x1C7, 0x1C9], + [0x1C8, 0x1C9], + [0x1CA, 0x1CC], + [0x1CB, 0x1CC], + [0x1CD, 0x1CE], + [0x1CF, 0x1D0], + [0x1D1, 0x1D2], + [0x1D3, 0x1D4], + [0x1D5, 0x1D6], + [0x1D7, 0x1D8], + [0x1D9, 0x1DA], + [0x1DB, 0x1DC], + [0x1DE, 0x1DF], + [0x1E0, 0x1E1], + [0x1E2, 0x1E3], + [0x1E4, 0x1E5], + [0x1E6, 0x1E7], + [0x1E8, 0x1E9], + [0x1EA, 0x1EB], + [0x1EC, 0x1ED], + [0x1EE, 0x1EF], + [0x1F1, 0x1F3], + [0x1F2, 0x1F3], + [0x1F4, 0x1F5], + [0x1F6, 0x195], + [0x1F7, 0x1BF], + [0x1F8, 0x1F9], + [0x1FA, 0x1FB], + [0x1FC, 0x1FD], + [0x1FE, 0x1FF], + [0x200, 0x201], + [0x202, 0x203], + [0x204, 0x205], + [0x206, 0x207], + [0x208, 0x209], + [0x20A, 0x20B], + [0x20C, 0x20D], + [0x20E, 0x20F], + [0x210, 0x211], + [0x212, 0x213], + [0x214, 0x215], + [0x216, 0x217], + [0x218, 0x219], + [0x21A, 0x21B], + [0x21C, 0x21D], + [0x21E, 0x21F], + [0x220, 0x19E], + [0x222, 0x223], + [0x224, 0x225], + [0x226, 0x227], + [0x228, 0x229], + [0x22A, 0x22B], + [0x22C, 0x22D], + [0x22E, 0x22F], + [0x230, 0x231], + [0x232, 0x233], + [0x23A, 0x2C65], + [0x23B, 0x23C], + [0x23D, 0x19A], + [0x23E, 0x2C66], + [0x241, 0x242], + [0x243, 0x180], + [0x244, 0x289], + [0x245, 0x28C], + [0x246, 0x247], + [0x248, 0x249], + [0x24A, 0x24B], + [0x24C, 0x24D], + [0x24E, 0x24F], + [0x345, 0x3B9], + [0x370, 0x371], + [0x372, 0x373], + [0x376, 0x377], + [0x37F, 0x3F3], + [0x386, 0x3AC], + [0x388, 0x3AD], + [0x389, 0x3AE], + [0x38A, 0x3AF], + [0x38C, 0x3CC], + [0x38E, 0x3CD], + [0x38F, 0x3CE], + [0x391, 0x3B1], + [0x392, 0x3B2], + [0x393, 0x3B3], + [0x394, 0x3B4], + [0x395, 0x3B5], + [0x396, 0x3B6], + [0x397, 0x3B7], + [0x398, 0x3B8], + [0x399, 0x3B9], + [0x39A, 0x3BA], + [0x39B, 0x3BB], + [0x39C, 0x3BC], + [0x39D, 0x3BD], + [0x39E, 0x3BE], + [0x39F, 0x3BF], + [0x3A0, 0x3C0], + [0x3A1, 0x3C1], + [0x3A3, 0x3C3], + [0x3A4, 0x3C4], + [0x3A5, 0x3C5], + [0x3A6, 0x3C6], + [0x3A7, 0x3C7], + [0x3A8, 0x3C8], + [0x3A9, 0x3C9], + [0x3AA, 0x3CA], + [0x3AB, 0x3CB], + [0x3C2, 0x3C3], + [0x3CF, 0x3D7], + [0x3D0, 0x3B2], + [0x3D1, 0x3B8], + [0x3D5, 0x3C6], + [0x3D6, 0x3C0], + [0x3D8, 0x3D9], + [0x3DA, 0x3DB], + [0x3DC, 0x3DD], + [0x3DE, 0x3DF], + [0x3E0, 0x3E1], + [0x3E2, 0x3E3], + [0x3E4, 0x3E5], + [0x3E6, 0x3E7], + [0x3E8, 0x3E9], + [0x3EA, 0x3EB], + [0x3EC, 0x3ED], + [0x3EE, 0x3EF], + [0x3F0, 0x3BA], + [0x3F1, 0x3C1], + [0x3F4, 0x3B8], + [0x3F5, 0x3B5], + [0x3F7, 0x3F8], + [0x3F9, 0x3F2], + [0x3FA, 0x3FB], + [0x3FD, 0x37B], + [0x3FE, 0x37C], + [0x3FF, 0x37D], + [0x400, 0x450], + [0x401, 0x451], + [0x402, 0x452], + [0x403, 0x453], + [0x404, 0x454], + [0x405, 0x455], + [0x406, 0x456], + [0x407, 0x457], + [0x408, 0x458], + [0x409, 0x459], + [0x40A, 0x45A], + [0x40B, 0x45B], + [0x40C, 0x45C], + [0x40D, 0x45D], + [0x40E, 0x45E], + [0x40F, 0x45F], + [0x410, 0x430], + [0x411, 0x431], + [0x412, 0x432], + [0x413, 0x433], + [0x414, 0x434], + [0x415, 0x435], + [0x416, 0x436], + [0x417, 0x437], + [0x418, 0x438], + [0x419, 0x439], + [0x41A, 0x43A], + [0x41B, 0x43B], + [0x41C, 0x43C], + [0x41D, 0x43D], + [0x41E, 0x43E], + [0x41F, 0x43F], + [0x420, 0x440], + [0x421, 0x441], + [0x422, 0x442], + [0x423, 0x443], + [0x424, 0x444], + [0x425, 0x445], + [0x426, 0x446], + [0x427, 0x447], + [0x428, 0x448], + [0x429, 0x449], + [0x42A, 0x44A], + [0x42B, 0x44B], + [0x42C, 0x44C], + [0x42D, 0x44D], + [0x42E, 0x44E], + [0x42F, 0x44F], + [0x460, 0x461], + [0x462, 0x463], + [0x464, 0x465], + [0x466, 0x467], + [0x468, 0x469], + [0x46A, 0x46B], + [0x46C, 0x46D], + [0x46E, 0x46F], + [0x470, 0x471], + [0x472, 0x473], + [0x474, 0x475], + [0x476, 0x477], + [0x478, 0x479], + [0x47A, 0x47B], + [0x47C, 0x47D], + [0x47E, 0x47F], + [0x480, 0x481], + [0x48A, 0x48B], + [0x48C, 0x48D], + [0x48E, 0x48F], + [0x490, 0x491], + [0x492, 0x493], + [0x494, 0x495], + [0x496, 0x497], + [0x498, 0x499], + [0x49A, 0x49B], + [0x49C, 0x49D], + [0x49E, 0x49F], + [0x4A0, 0x4A1], + [0x4A2, 0x4A3], + [0x4A4, 0x4A5], + [0x4A6, 0x4A7], + [0x4A8, 0x4A9], + [0x4AA, 0x4AB], + [0x4AC, 0x4AD], + [0x4AE, 0x4AF], + [0x4B0, 0x4B1], + [0x4B2, 0x4B3], + [0x4B4, 0x4B5], + [0x4B6, 0x4B7], + [0x4B8, 0x4B9], + [0x4BA, 0x4BB], + [0x4BC, 0x4BD], + [0x4BE, 0x4BF], + [0x4C0, 0x4CF], + [0x4C1, 0x4C2], + [0x4C3, 0x4C4], + [0x4C5, 0x4C6], + [0x4C7, 0x4C8], + [0x4C9, 0x4CA], + [0x4CB, 0x4CC], + [0x4CD, 0x4CE], + [0x4D0, 0x4D1], + [0x4D2, 0x4D3], + [0x4D4, 0x4D5], + [0x4D6, 0x4D7], + [0x4D8, 0x4D9], + [0x4DA, 0x4DB], + [0x4DC, 0x4DD], + [0x4DE, 0x4DF], + [0x4E0, 0x4E1], + [0x4E2, 0x4E3], + [0x4E4, 0x4E5], + [0x4E6, 0x4E7], + [0x4E8, 0x4E9], + [0x4EA, 0x4EB], + [0x4EC, 0x4ED], + [0x4EE, 0x4EF], + [0x4F0, 0x4F1], + [0x4F2, 0x4F3], + [0x4F4, 0x4F5], + [0x4F6, 0x4F7], + [0x4F8, 0x4F9], + [0x4FA, 0x4FB], + [0x4FC, 0x4FD], + [0x4FE, 0x4FF], + [0x500, 0x501], + [0x502, 0x503], + [0x504, 0x505], + [0x506, 0x507], + [0x508, 0x509], + [0x50A, 0x50B], + [0x50C, 0x50D], + [0x50E, 0x50F], + [0x510, 0x511], + [0x512, 0x513], + [0x514, 0x515], + [0x516, 0x517], + [0x518, 0x519], + [0x51A, 0x51B], + [0x51C, 0x51D], + [0x51E, 0x51F], + [0x520, 0x521], + [0x522, 0x523], + [0x524, 0x525], + [0x526, 0x527], + [0x528, 0x529], + [0x52A, 0x52B], + [0x52C, 0x52D], + [0x52E, 0x52F], + [0x531, 0x561], + [0x532, 0x562], + [0x533, 0x563], + [0x534, 0x564], + [0x535, 0x565], + [0x536, 0x566], + [0x537, 0x567], + [0x538, 0x568], + [0x539, 0x569], + [0x53A, 0x56A], + [0x53B, 0x56B], + [0x53C, 0x56C], + [0x53D, 0x56D], + [0x53E, 0x56E], + [0x53F, 0x56F], + [0x540, 0x570], + [0x541, 0x571], + [0x542, 0x572], + [0x543, 0x573], + [0x544, 0x574], + [0x545, 0x575], + [0x546, 0x576], + [0x547, 0x577], + [0x548, 0x578], + [0x549, 0x579], + [0x54A, 0x57A], + [0x54B, 0x57B], + [0x54C, 0x57C], + [0x54D, 0x57D], + [0x54E, 0x57E], + [0x54F, 0x57F], + [0x550, 0x580], + [0x551, 0x581], + [0x552, 0x582], + [0x553, 0x583], + [0x554, 0x584], + [0x555, 0x585], + [0x556, 0x586], + [0x10A0, 0x2D00], + [0x10A1, 0x2D01], + [0x10A2, 0x2D02], + [0x10A3, 0x2D03], + [0x10A4, 0x2D04], + [0x10A5, 0x2D05], + [0x10A6, 0x2D06], + [0x10A7, 0x2D07], + [0x10A8, 0x2D08], + [0x10A9, 0x2D09], + [0x10AA, 0x2D0A], + [0x10AB, 0x2D0B], + [0x10AC, 0x2D0C], + [0x10AD, 0x2D0D], + [0x10AE, 0x2D0E], + [0x10AF, 0x2D0F], + [0x10B0, 0x2D10], + [0x10B1, 0x2D11], + [0x10B2, 0x2D12], + [0x10B3, 0x2D13], + [0x10B4, 0x2D14], + [0x10B5, 0x2D15], + [0x10B6, 0x2D16], + [0x10B7, 0x2D17], + [0x10B8, 0x2D18], + [0x10B9, 0x2D19], + [0x10BA, 0x2D1A], + [0x10BB, 0x2D1B], + [0x10BC, 0x2D1C], + [0x10BD, 0x2D1D], + [0x10BE, 0x2D1E], + [0x10BF, 0x2D1F], + [0x10C0, 0x2D20], + [0x10C1, 0x2D21], + [0x10C2, 0x2D22], + [0x10C3, 0x2D23], + [0x10C4, 0x2D24], + [0x10C5, 0x2D25], + [0x10C7, 0x2D27], + [0x10CD, 0x2D2D], + [0x13F8, 0x13F0], + [0x13F9, 0x13F1], + [0x13FA, 0x13F2], + [0x13FB, 0x13F3], + [0x13FC, 0x13F4], + [0x13FD, 0x13F5], + [0x1C80, 0x432], + [0x1C81, 0x434], + [0x1C82, 0x43E], + [0x1C83, 0x441], + [0x1C84, 0x442], + [0x1C85, 0x442], + [0x1C86, 0x44A], + [0x1C87, 0x463], + [0x1C88, 0xA64B], + [0x1C89, 0x1C8A], + [0x1C90, 0x10D0], + [0x1C91, 0x10D1], + [0x1C92, 0x10D2], + [0x1C93, 0x10D3], + [0x1C94, 0x10D4], + [0x1C95, 0x10D5], + [0x1C96, 0x10D6], + [0x1C97, 0x10D7], + [0x1C98, 0x10D8], + [0x1C99, 0x10D9], + [0x1C9A, 0x10DA], + [0x1C9B, 0x10DB], + [0x1C9C, 0x10DC], + [0x1C9D, 0x10DD], + [0x1C9E, 0x10DE], + [0x1C9F, 0x10DF], + [0x1CA0, 0x10E0], + [0x1CA1, 0x10E1], + [0x1CA2, 0x10E2], + [0x1CA3, 0x10E3], + [0x1CA4, 0x10E4], + [0x1CA5, 0x10E5], + [0x1CA6, 0x10E6], + [0x1CA7, 0x10E7], + [0x1CA8, 0x10E8], + [0x1CA9, 0x10E9], + [0x1CAA, 0x10EA], + [0x1CAB, 0x10EB], + [0x1CAC, 0x10EC], + [0x1CAD, 0x10ED], + [0x1CAE, 0x10EE], + [0x1CAF, 0x10EF], + [0x1CB0, 0x10F0], + [0x1CB1, 0x10F1], + [0x1CB2, 0x10F2], + [0x1CB3, 0x10F3], + [0x1CB4, 0x10F4], + [0x1CB5, 0x10F5], + [0x1CB6, 0x10F6], + [0x1CB7, 0x10F7], + [0x1CB8, 0x10F8], + [0x1CB9, 0x10F9], + [0x1CBA, 0x10FA], + [0x1CBD, 0x10FD], + [0x1CBE, 0x10FE], + [0x1CBF, 0x10FF], + [0x1E00, 0x1E01], + [0x1E02, 0x1E03], + [0x1E04, 0x1E05], + [0x1E06, 0x1E07], + [0x1E08, 0x1E09], + [0x1E0A, 0x1E0B], + [0x1E0C, 0x1E0D], + [0x1E0E, 0x1E0F], + [0x1E10, 0x1E11], + [0x1E12, 0x1E13], + [0x1E14, 0x1E15], + [0x1E16, 0x1E17], + [0x1E18, 0x1E19], + [0x1E1A, 0x1E1B], + [0x1E1C, 0x1E1D], + [0x1E1E, 0x1E1F], + [0x1E20, 0x1E21], + [0x1E22, 0x1E23], + [0x1E24, 0x1E25], + [0x1E26, 0x1E27], + [0x1E28, 0x1E29], + [0x1E2A, 0x1E2B], + [0x1E2C, 0x1E2D], + [0x1E2E, 0x1E2F], + [0x1E30, 0x1E31], + [0x1E32, 0x1E33], + [0x1E34, 0x1E35], + [0x1E36, 0x1E37], + [0x1E38, 0x1E39], + [0x1E3A, 0x1E3B], + [0x1E3C, 0x1E3D], + [0x1E3E, 0x1E3F], + [0x1E40, 0x1E41], + [0x1E42, 0x1E43], + [0x1E44, 0x1E45], + [0x1E46, 0x1E47], + [0x1E48, 0x1E49], + [0x1E4A, 0x1E4B], + [0x1E4C, 0x1E4D], + [0x1E4E, 0x1E4F], + [0x1E50, 0x1E51], + [0x1E52, 0x1E53], + [0x1E54, 0x1E55], + [0x1E56, 0x1E57], + [0x1E58, 0x1E59], + [0x1E5A, 0x1E5B], + [0x1E5C, 0x1E5D], + [0x1E5E, 0x1E5F], + [0x1E60, 0x1E61], + [0x1E62, 0x1E63], + [0x1E64, 0x1E65], + [0x1E66, 0x1E67], + [0x1E68, 0x1E69], + [0x1E6A, 0x1E6B], + [0x1E6C, 0x1E6D], + [0x1E6E, 0x1E6F], + [0x1E70, 0x1E71], + [0x1E72, 0x1E73], + [0x1E74, 0x1E75], + [0x1E76, 0x1E77], + [0x1E78, 0x1E79], + [0x1E7A, 0x1E7B], + [0x1E7C, 0x1E7D], + [0x1E7E, 0x1E7F], + [0x1E80, 0x1E81], + [0x1E82, 0x1E83], + [0x1E84, 0x1E85], + [0x1E86, 0x1E87], + [0x1E88, 0x1E89], + [0x1E8A, 0x1E8B], + [0x1E8C, 0x1E8D], + [0x1E8E, 0x1E8F], + [0x1E90, 0x1E91], + [0x1E92, 0x1E93], + [0x1E94, 0x1E95], + [0x1E9B, 0x1E61], + [0x1E9E, 0xDF], + [0x1EA0, 0x1EA1], + [0x1EA2, 0x1EA3], + [0x1EA4, 0x1EA5], + [0x1EA6, 0x1EA7], + [0x1EA8, 0x1EA9], + [0x1EAA, 0x1EAB], + [0x1EAC, 0x1EAD], + [0x1EAE, 0x1EAF], + [0x1EB0, 0x1EB1], + [0x1EB2, 0x1EB3], + [0x1EB4, 0x1EB5], + [0x1EB6, 0x1EB7], + [0x1EB8, 0x1EB9], + [0x1EBA, 0x1EBB], + [0x1EBC, 0x1EBD], + [0x1EBE, 0x1EBF], + [0x1EC0, 0x1EC1], + [0x1EC2, 0x1EC3], + [0x1EC4, 0x1EC5], + [0x1EC6, 0x1EC7], + [0x1EC8, 0x1EC9], + [0x1ECA, 0x1ECB], + [0x1ECC, 0x1ECD], + [0x1ECE, 0x1ECF], + [0x1ED0, 0x1ED1], + [0x1ED2, 0x1ED3], + [0x1ED4, 0x1ED5], + [0x1ED6, 0x1ED7], + [0x1ED8, 0x1ED9], + [0x1EDA, 0x1EDB], + [0x1EDC, 0x1EDD], + [0x1EDE, 0x1EDF], + [0x1EE0, 0x1EE1], + [0x1EE2, 0x1EE3], + [0x1EE4, 0x1EE5], + [0x1EE6, 0x1EE7], + [0x1EE8, 0x1EE9], + [0x1EEA, 0x1EEB], + [0x1EEC, 0x1EED], + [0x1EEE, 0x1EEF], + [0x1EF0, 0x1EF1], + [0x1EF2, 0x1EF3], + [0x1EF4, 0x1EF5], + [0x1EF6, 0x1EF7], + [0x1EF8, 0x1EF9], + [0x1EFA, 0x1EFB], + [0x1EFC, 0x1EFD], + [0x1EFE, 0x1EFF], + [0x1F08, 0x1F00], + [0x1F09, 0x1F01], + [0x1F0A, 0x1F02], + [0x1F0B, 0x1F03], + [0x1F0C, 0x1F04], + [0x1F0D, 0x1F05], + [0x1F0E, 0x1F06], + [0x1F0F, 0x1F07], + [0x1F18, 0x1F10], + [0x1F19, 0x1F11], + [0x1F1A, 0x1F12], + [0x1F1B, 0x1F13], + [0x1F1C, 0x1F14], + [0x1F1D, 0x1F15], + [0x1F28, 0x1F20], + [0x1F29, 0x1F21], + [0x1F2A, 0x1F22], + [0x1F2B, 0x1F23], + [0x1F2C, 0x1F24], + [0x1F2D, 0x1F25], + [0x1F2E, 0x1F26], + [0x1F2F, 0x1F27], + [0x1F38, 0x1F30], + [0x1F39, 0x1F31], + [0x1F3A, 0x1F32], + [0x1F3B, 0x1F33], + [0x1F3C, 0x1F34], + [0x1F3D, 0x1F35], + [0x1F3E, 0x1F36], + [0x1F3F, 0x1F37], + [0x1F48, 0x1F40], + [0x1F49, 0x1F41], + [0x1F4A, 0x1F42], + [0x1F4B, 0x1F43], + [0x1F4C, 0x1F44], + [0x1F4D, 0x1F45], + [0x1F59, 0x1F51], + [0x1F5B, 0x1F53], + [0x1F5D, 0x1F55], + [0x1F5F, 0x1F57], + [0x1F68, 0x1F60], + [0x1F69, 0x1F61], + [0x1F6A, 0x1F62], + [0x1F6B, 0x1F63], + [0x1F6C, 0x1F64], + [0x1F6D, 0x1F65], + [0x1F6E, 0x1F66], + [0x1F6F, 0x1F67], + [0x1F88, 0x1F80], + [0x1F89, 0x1F81], + [0x1F8A, 0x1F82], + [0x1F8B, 0x1F83], + [0x1F8C, 0x1F84], + [0x1F8D, 0x1F85], + [0x1F8E, 0x1F86], + [0x1F8F, 0x1F87], + [0x1F98, 0x1F90], + [0x1F99, 0x1F91], + [0x1F9A, 0x1F92], + [0x1F9B, 0x1F93], + [0x1F9C, 0x1F94], + [0x1F9D, 0x1F95], + [0x1F9E, 0x1F96], + [0x1F9F, 0x1F97], + [0x1FA8, 0x1FA0], + [0x1FA9, 0x1FA1], + [0x1FAA, 0x1FA2], + [0x1FAB, 0x1FA3], + [0x1FAC, 0x1FA4], + [0x1FAD, 0x1FA5], + [0x1FAE, 0x1FA6], + [0x1FAF, 0x1FA7], + [0x1FB8, 0x1FB0], + [0x1FB9, 0x1FB1], + [0x1FBA, 0x1F70], + [0x1FBB, 0x1F71], + [0x1FBC, 0x1FB3], + [0x1FBE, 0x3B9], + [0x1FC8, 0x1F72], + [0x1FC9, 0x1F73], + [0x1FCA, 0x1F74], + [0x1FCB, 0x1F75], + [0x1FCC, 0x1FC3], + [0x1FD3, 0x390], + [0x1FD8, 0x1FD0], + [0x1FD9, 0x1FD1], + [0x1FDA, 0x1F76], + [0x1FDB, 0x1F77], + [0x1FE3, 0x3B0], + [0x1FE8, 0x1FE0], + [0x1FE9, 0x1FE1], + [0x1FEA, 0x1F7A], + [0x1FEB, 0x1F7B], + [0x1FEC, 0x1FE5], + [0x1FF8, 0x1F78], + [0x1FF9, 0x1F79], + [0x1FFA, 0x1F7C], + [0x1FFB, 0x1F7D], + [0x1FFC, 0x1FF3], + [0x2126, 0x3C9], + [0x212A, 0x6B], + [0x212B, 0xE5], + [0x2132, 0x214E], + [0x2160, 0x2170], + [0x2161, 0x2171], + [0x2162, 0x2172], + [0x2163, 0x2173], + [0x2164, 0x2174], + [0x2165, 0x2175], + [0x2166, 0x2176], + [0x2167, 0x2177], + [0x2168, 0x2178], + [0x2169, 0x2179], + [0x216A, 0x217A], + [0x216B, 0x217B], + [0x216C, 0x217C], + [0x216D, 0x217D], + [0x216E, 0x217E], + [0x216F, 0x217F], + [0x2183, 0x2184], + [0x24B6, 0x24D0], + [0x24B7, 0x24D1], + [0x24B8, 0x24D2], + [0x24B9, 0x24D3], + [0x24BA, 0x24D4], + [0x24BB, 0x24D5], + [0x24BC, 0x24D6], + [0x24BD, 0x24D7], + [0x24BE, 0x24D8], + [0x24BF, 0x24D9], + [0x24C0, 0x24DA], + [0x24C1, 0x24DB], + [0x24C2, 0x24DC], + [0x24C3, 0x24DD], + [0x24C4, 0x24DE], + [0x24C5, 0x24DF], + [0x24C6, 0x24E0], + [0x24C7, 0x24E1], + [0x24C8, 0x24E2], + [0x24C9, 0x24E3], + [0x24CA, 0x24E4], + [0x24CB, 0x24E5], + [0x24CC, 0x24E6], + [0x24CD, 0x24E7], + [0x24CE, 0x24E8], + [0x24CF, 0x24E9], + [0x2C00, 0x2C30], + [0x2C01, 0x2C31], + [0x2C02, 0x2C32], + [0x2C03, 0x2C33], + [0x2C04, 0x2C34], + [0x2C05, 0x2C35], + [0x2C06, 0x2C36], + [0x2C07, 0x2C37], + [0x2C08, 0x2C38], + [0x2C09, 0x2C39], + [0x2C0A, 0x2C3A], + [0x2C0B, 0x2C3B], + [0x2C0C, 0x2C3C], + [0x2C0D, 0x2C3D], + [0x2C0E, 0x2C3E], + [0x2C0F, 0x2C3F], + [0x2C10, 0x2C40], + [0x2C11, 0x2C41], + [0x2C12, 0x2C42], + [0x2C13, 0x2C43], + [0x2C14, 0x2C44], + [0x2C15, 0x2C45], + [0x2C16, 0x2C46], + [0x2C17, 0x2C47], + [0x2C18, 0x2C48], + [0x2C19, 0x2C49], + [0x2C1A, 0x2C4A], + [0x2C1B, 0x2C4B], + [0x2C1C, 0x2C4C], + [0x2C1D, 0x2C4D], + [0x2C1E, 0x2C4E], + [0x2C1F, 0x2C4F], + [0x2C20, 0x2C50], + [0x2C21, 0x2C51], + [0x2C22, 0x2C52], + [0x2C23, 0x2C53], + [0x2C24, 0x2C54], + [0x2C25, 0x2C55], + [0x2C26, 0x2C56], + [0x2C27, 0x2C57], + [0x2C28, 0x2C58], + [0x2C29, 0x2C59], + [0x2C2A, 0x2C5A], + [0x2C2B, 0x2C5B], + [0x2C2C, 0x2C5C], + [0x2C2D, 0x2C5D], + [0x2C2E, 0x2C5E], + [0x2C2F, 0x2C5F], + [0x2C60, 0x2C61], + [0x2C62, 0x26B], + [0x2C63, 0x1D7D], + [0x2C64, 0x27D], + [0x2C67, 0x2C68], + [0x2C69, 0x2C6A], + [0x2C6B, 0x2C6C], + [0x2C6D, 0x251], + [0x2C6E, 0x271], + [0x2C6F, 0x250], + [0x2C70, 0x252], + [0x2C72, 0x2C73], + [0x2C75, 0x2C76], + [0x2C7E, 0x23F], + [0x2C7F, 0x240], + [0x2C80, 0x2C81], + [0x2C82, 0x2C83], + [0x2C84, 0x2C85], + [0x2C86, 0x2C87], + [0x2C88, 0x2C89], + [0x2C8A, 0x2C8B], + [0x2C8C, 0x2C8D], + [0x2C8E, 0x2C8F], + [0x2C90, 0x2C91], + [0x2C92, 0x2C93], + [0x2C94, 0x2C95], + [0x2C96, 0x2C97], + [0x2C98, 0x2C99], + [0x2C9A, 0x2C9B], + [0x2C9C, 0x2C9D], + [0x2C9E, 0x2C9F], + [0x2CA0, 0x2CA1], + [0x2CA2, 0x2CA3], + [0x2CA4, 0x2CA5], + [0x2CA6, 0x2CA7], + [0x2CA8, 0x2CA9], + [0x2CAA, 0x2CAB], + [0x2CAC, 0x2CAD], + [0x2CAE, 0x2CAF], + [0x2CB0, 0x2CB1], + [0x2CB2, 0x2CB3], + [0x2CB4, 0x2CB5], + [0x2CB6, 0x2CB7], + [0x2CB8, 0x2CB9], + [0x2CBA, 0x2CBB], + [0x2CBC, 0x2CBD], + [0x2CBE, 0x2CBF], + [0x2CC0, 0x2CC1], + [0x2CC2, 0x2CC3], + [0x2CC4, 0x2CC5], + [0x2CC6, 0x2CC7], + [0x2CC8, 0x2CC9], + [0x2CCA, 0x2CCB], + [0x2CCC, 0x2CCD], + [0x2CCE, 0x2CCF], + [0x2CD0, 0x2CD1], + [0x2CD2, 0x2CD3], + [0x2CD4, 0x2CD5], + [0x2CD6, 0x2CD7], + [0x2CD8, 0x2CD9], + [0x2CDA, 0x2CDB], + [0x2CDC, 0x2CDD], + [0x2CDE, 0x2CDF], + [0x2CE0, 0x2CE1], + [0x2CE2, 0x2CE3], + [0x2CEB, 0x2CEC], + [0x2CED, 0x2CEE], + [0x2CF2, 0x2CF3], + [0xA640, 0xA641], + [0xA642, 0xA643], + [0xA644, 0xA645], + [0xA646, 0xA647], + [0xA648, 0xA649], + [0xA64A, 0xA64B], + [0xA64C, 0xA64D], + [0xA64E, 0xA64F], + [0xA650, 0xA651], + [0xA652, 0xA653], + [0xA654, 0xA655], + [0xA656, 0xA657], + [0xA658, 0xA659], + [0xA65A, 0xA65B], + [0xA65C, 0xA65D], + [0xA65E, 0xA65F], + [0xA660, 0xA661], + [0xA662, 0xA663], + [0xA664, 0xA665], + [0xA666, 0xA667], + [0xA668, 0xA669], + [0xA66A, 0xA66B], + [0xA66C, 0xA66D], + [0xA680, 0xA681], + [0xA682, 0xA683], + [0xA684, 0xA685], + [0xA686, 0xA687], + [0xA688, 0xA689], + [0xA68A, 0xA68B], + [0xA68C, 0xA68D], + [0xA68E, 0xA68F], + [0xA690, 0xA691], + [0xA692, 0xA693], + [0xA694, 0xA695], + [0xA696, 0xA697], + [0xA698, 0xA699], + [0xA69A, 0xA69B], + [0xA722, 0xA723], + [0xA724, 0xA725], + [0xA726, 0xA727], + [0xA728, 0xA729], + [0xA72A, 0xA72B], + [0xA72C, 0xA72D], + [0xA72E, 0xA72F], + [0xA732, 0xA733], + [0xA734, 0xA735], + [0xA736, 0xA737], + [0xA738, 0xA739], + [0xA73A, 0xA73B], + [0xA73C, 0xA73D], + [0xA73E, 0xA73F], + [0xA740, 0xA741], + [0xA742, 0xA743], + [0xA744, 0xA745], + [0xA746, 0xA747], + [0xA748, 0xA749], + [0xA74A, 0xA74B], + [0xA74C, 0xA74D], + [0xA74E, 0xA74F], + [0xA750, 0xA751], + [0xA752, 0xA753], + [0xA754, 0xA755], + [0xA756, 0xA757], + [0xA758, 0xA759], + [0xA75A, 0xA75B], + [0xA75C, 0xA75D], + [0xA75E, 0xA75F], + [0xA760, 0xA761], + [0xA762, 0xA763], + [0xA764, 0xA765], + [0xA766, 0xA767], + [0xA768, 0xA769], + [0xA76A, 0xA76B], + [0xA76C, 0xA76D], + [0xA76E, 0xA76F], + [0xA779, 0xA77A], + [0xA77B, 0xA77C], + [0xA77D, 0x1D79], + [0xA77E, 0xA77F], + [0xA780, 0xA781], + [0xA782, 0xA783], + [0xA784, 0xA785], + [0xA786, 0xA787], + [0xA78B, 0xA78C], + [0xA78D, 0x265], + [0xA790, 0xA791], + [0xA792, 0xA793], + [0xA796, 0xA797], + [0xA798, 0xA799], + [0xA79A, 0xA79B], + [0xA79C, 0xA79D], + [0xA79E, 0xA79F], + [0xA7A0, 0xA7A1], + [0xA7A2, 0xA7A3], + [0xA7A4, 0xA7A5], + [0xA7A6, 0xA7A7], + [0xA7A8, 0xA7A9], + [0xA7AA, 0x266], + [0xA7AB, 0x25C], + [0xA7AC, 0x261], + [0xA7AD, 0x26C], + [0xA7AE, 0x26A], + [0xA7B0, 0x29E], + [0xA7B1, 0x287], + [0xA7B2, 0x29D], + [0xA7B3, 0xAB53], + [0xA7B4, 0xA7B5], + [0xA7B6, 0xA7B7], + [0xA7B8, 0xA7B9], + [0xA7BA, 0xA7BB], + [0xA7BC, 0xA7BD], + [0xA7BE, 0xA7BF], + [0xA7C0, 0xA7C1], + [0xA7C2, 0xA7C3], + [0xA7C4, 0xA794], + [0xA7C5, 0x282], + [0xA7C6, 0x1D8E], + [0xA7C7, 0xA7C8], + [0xA7C9, 0xA7CA], + [0xA7CB, 0x264], + [0xA7CC, 0xA7CD], + [0xA7CE, 0xA7CF], + [0xA7D0, 0xA7D1], + [0xA7D2, 0xA7D3], + [0xA7D4, 0xA7D5], + [0xA7D6, 0xA7D7], + [0xA7D8, 0xA7D9], + [0xA7DA, 0xA7DB], + [0xA7DC, 0x19B], + [0xA7F5, 0xA7F6], + [0xAB70, 0x13A0], + [0xAB71, 0x13A1], + [0xAB72, 0x13A2], + [0xAB73, 0x13A3], + [0xAB74, 0x13A4], + [0xAB75, 0x13A5], + [0xAB76, 0x13A6], + [0xAB77, 0x13A7], + [0xAB78, 0x13A8], + [0xAB79, 0x13A9], + [0xAB7A, 0x13AA], + [0xAB7B, 0x13AB], + [0xAB7C, 0x13AC], + [0xAB7D, 0x13AD], + [0xAB7E, 0x13AE], + [0xAB7F, 0x13AF], + [0xAB80, 0x13B0], + [0xAB81, 0x13B1], + [0xAB82, 0x13B2], + [0xAB83, 0x13B3], + [0xAB84, 0x13B4], + [0xAB85, 0x13B5], + [0xAB86, 0x13B6], + [0xAB87, 0x13B7], + [0xAB88, 0x13B8], + [0xAB89, 0x13B9], + [0xAB8A, 0x13BA], + [0xAB8B, 0x13BB], + [0xAB8C, 0x13BC], + [0xAB8D, 0x13BD], + [0xAB8E, 0x13BE], + [0xAB8F, 0x13BF], + [0xAB90, 0x13C0], + [0xAB91, 0x13C1], + [0xAB92, 0x13C2], + [0xAB93, 0x13C3], + [0xAB94, 0x13C4], + [0xAB95, 0x13C5], + [0xAB96, 0x13C6], + [0xAB97, 0x13C7], + [0xAB98, 0x13C8], + [0xAB99, 0x13C9], + [0xAB9A, 0x13CA], + [0xAB9B, 0x13CB], + [0xAB9C, 0x13CC], + [0xAB9D, 0x13CD], + [0xAB9E, 0x13CE], + [0xAB9F, 0x13CF], + [0xABA0, 0x13D0], + [0xABA1, 0x13D1], + [0xABA2, 0x13D2], + [0xABA3, 0x13D3], + [0xABA4, 0x13D4], + [0xABA5, 0x13D5], + [0xABA6, 0x13D6], + [0xABA7, 0x13D7], + [0xABA8, 0x13D8], + [0xABA9, 0x13D9], + [0xABAA, 0x13DA], + [0xABAB, 0x13DB], + [0xABAC, 0x13DC], + [0xABAD, 0x13DD], + [0xABAE, 0x13DE], + [0xABAF, 0x13DF], + [0xABB0, 0x13E0], + [0xABB1, 0x13E1], + [0xABB2, 0x13E2], + [0xABB3, 0x13E3], + [0xABB4, 0x13E4], + [0xABB5, 0x13E5], + [0xABB6, 0x13E6], + [0xABB7, 0x13E7], + [0xABB8, 0x13E8], + [0xABB9, 0x13E9], + [0xABBA, 0x13EA], + [0xABBB, 0x13EB], + [0xABBC, 0x13EC], + [0xABBD, 0x13ED], + [0xABBE, 0x13EE], + [0xABBF, 0x13EF], + [0xFB05, 0xFB06], + [0xFF21, 0xFF41], + [0xFF22, 0xFF42], + [0xFF23, 0xFF43], + [0xFF24, 0xFF44], + [0xFF25, 0xFF45], + [0xFF26, 0xFF46], + [0xFF27, 0xFF47], + [0xFF28, 0xFF48], + [0xFF29, 0xFF49], + [0xFF2A, 0xFF4A], + [0xFF2B, 0xFF4B], + [0xFF2C, 0xFF4C], + [0xFF2D, 0xFF4D], + [0xFF2E, 0xFF4E], + [0xFF2F, 0xFF4F], + [0xFF30, 0xFF50], + [0xFF31, 0xFF51], + [0xFF32, 0xFF52], + [0xFF33, 0xFF53], + [0xFF34, 0xFF54], + [0xFF35, 0xFF55], + [0xFF36, 0xFF56], + [0xFF37, 0xFF57], + [0xFF38, 0xFF58], + [0xFF39, 0xFF59], + [0xFF3A, 0xFF5A], + [0x10400, 0x10428], + [0x10401, 0x10429], + [0x10402, 0x1042A], + [0x10403, 0x1042B], + [0x10404, 0x1042C], + [0x10405, 0x1042D], + [0x10406, 0x1042E], + [0x10407, 0x1042F], + [0x10408, 0x10430], + [0x10409, 0x10431], + [0x1040A, 0x10432], + [0x1040B, 0x10433], + [0x1040C, 0x10434], + [0x1040D, 0x10435], + [0x1040E, 0x10436], + [0x1040F, 0x10437], + [0x10410, 0x10438], + [0x10411, 0x10439], + [0x10412, 0x1043A], + [0x10413, 0x1043B], + [0x10414, 0x1043C], + [0x10415, 0x1043D], + [0x10416, 0x1043E], + [0x10417, 0x1043F], + [0x10418, 0x10440], + [0x10419, 0x10441], + [0x1041A, 0x10442], + [0x1041B, 0x10443], + [0x1041C, 0x10444], + [0x1041D, 0x10445], + [0x1041E, 0x10446], + [0x1041F, 0x10447], + [0x10420, 0x10448], + [0x10421, 0x10449], + [0x10422, 0x1044A], + [0x10423, 0x1044B], + [0x10424, 0x1044C], + [0x10425, 0x1044D], + [0x10426, 0x1044E], + [0x10427, 0x1044F], + [0x104B0, 0x104D8], + [0x104B1, 0x104D9], + [0x104B2, 0x104DA], + [0x104B3, 0x104DB], + [0x104B4, 0x104DC], + [0x104B5, 0x104DD], + [0x104B6, 0x104DE], + [0x104B7, 0x104DF], + [0x104B8, 0x104E0], + [0x104B9, 0x104E1], + [0x104BA, 0x104E2], + [0x104BB, 0x104E3], + [0x104BC, 0x104E4], + [0x104BD, 0x104E5], + [0x104BE, 0x104E6], + [0x104BF, 0x104E7], + [0x104C0, 0x104E8], + [0x104C1, 0x104E9], + [0x104C2, 0x104EA], + [0x104C3, 0x104EB], + [0x104C4, 0x104EC], + [0x104C5, 0x104ED], + [0x104C6, 0x104EE], + [0x104C7, 0x104EF], + [0x104C8, 0x104F0], + [0x104C9, 0x104F1], + [0x104CA, 0x104F2], + [0x104CB, 0x104F3], + [0x104CC, 0x104F4], + [0x104CD, 0x104F5], + [0x104CE, 0x104F6], + [0x104CF, 0x104F7], + [0x104D0, 0x104F8], + [0x104D1, 0x104F9], + [0x104D2, 0x104FA], + [0x104D3, 0x104FB], + [0x10570, 0x10597], + [0x10571, 0x10598], + [0x10572, 0x10599], + [0x10573, 0x1059A], + [0x10574, 0x1059B], + [0x10575, 0x1059C], + [0x10576, 0x1059D], + [0x10577, 0x1059E], + [0x10578, 0x1059F], + [0x10579, 0x105A0], + [0x1057A, 0x105A1], + [0x1057C, 0x105A3], + [0x1057D, 0x105A4], + [0x1057E, 0x105A5], + [0x1057F, 0x105A6], + [0x10580, 0x105A7], + [0x10581, 0x105A8], + [0x10582, 0x105A9], + [0x10583, 0x105AA], + [0x10584, 0x105AB], + [0x10585, 0x105AC], + [0x10586, 0x105AD], + [0x10587, 0x105AE], + [0x10588, 0x105AF], + [0x10589, 0x105B0], + [0x1058A, 0x105B1], + [0x1058C, 0x105B3], + [0x1058D, 0x105B4], + [0x1058E, 0x105B5], + [0x1058F, 0x105B6], + [0x10590, 0x105B7], + [0x10591, 0x105B8], + [0x10592, 0x105B9], + [0x10594, 0x105BB], + [0x10595, 0x105BC], + [0x10C80, 0x10CC0], + [0x10C81, 0x10CC1], + [0x10C82, 0x10CC2], + [0x10C83, 0x10CC3], + [0x10C84, 0x10CC4], + [0x10C85, 0x10CC5], + [0x10C86, 0x10CC6], + [0x10C87, 0x10CC7], + [0x10C88, 0x10CC8], + [0x10C89, 0x10CC9], + [0x10C8A, 0x10CCA], + [0x10C8B, 0x10CCB], + [0x10C8C, 0x10CCC], + [0x10C8D, 0x10CCD], + [0x10C8E, 0x10CCE], + [0x10C8F, 0x10CCF], + [0x10C90, 0x10CD0], + [0x10C91, 0x10CD1], + [0x10C92, 0x10CD2], + [0x10C93, 0x10CD3], + [0x10C94, 0x10CD4], + [0x10C95, 0x10CD5], + [0x10C96, 0x10CD6], + [0x10C97, 0x10CD7], + [0x10C98, 0x10CD8], + [0x10C99, 0x10CD9], + [0x10C9A, 0x10CDA], + [0x10C9B, 0x10CDB], + [0x10C9C, 0x10CDC], + [0x10C9D, 0x10CDD], + [0x10C9E, 0x10CDE], + [0x10C9F, 0x10CDF], + [0x10CA0, 0x10CE0], + [0x10CA1, 0x10CE1], + [0x10CA2, 0x10CE2], + [0x10CA3, 0x10CE3], + [0x10CA4, 0x10CE4], + [0x10CA5, 0x10CE5], + [0x10CA6, 0x10CE6], + [0x10CA7, 0x10CE7], + [0x10CA8, 0x10CE8], + [0x10CA9, 0x10CE9], + [0x10CAA, 0x10CEA], + [0x10CAB, 0x10CEB], + [0x10CAC, 0x10CEC], + [0x10CAD, 0x10CED], + [0x10CAE, 0x10CEE], + [0x10CAF, 0x10CEF], + [0x10CB0, 0x10CF0], + [0x10CB1, 0x10CF1], + [0x10CB2, 0x10CF2], + [0x10D50, 0x10D70], + [0x10D51, 0x10D71], + [0x10D52, 0x10D72], + [0x10D53, 0x10D73], + [0x10D54, 0x10D74], + [0x10D55, 0x10D75], + [0x10D56, 0x10D76], + [0x10D57, 0x10D77], + [0x10D58, 0x10D78], + [0x10D59, 0x10D79], + [0x10D5A, 0x10D7A], + [0x10D5B, 0x10D7B], + [0x10D5C, 0x10D7C], + [0x10D5D, 0x10D7D], + [0x10D5E, 0x10D7E], + [0x10D5F, 0x10D7F], + [0x10D60, 0x10D80], + [0x10D61, 0x10D81], + [0x10D62, 0x10D82], + [0x10D63, 0x10D83], + [0x10D64, 0x10D84], + [0x10D65, 0x10D85], + [0x118A0, 0x118C0], + [0x118A1, 0x118C1], + [0x118A2, 0x118C2], + [0x118A3, 0x118C3], + [0x118A4, 0x118C4], + [0x118A5, 0x118C5], + [0x118A6, 0x118C6], + [0x118A7, 0x118C7], + [0x118A8, 0x118C8], + [0x118A9, 0x118C9], + [0x118AA, 0x118CA], + [0x118AB, 0x118CB], + [0x118AC, 0x118CC], + [0x118AD, 0x118CD], + [0x118AE, 0x118CE], + [0x118AF, 0x118CF], + [0x118B0, 0x118D0], + [0x118B1, 0x118D1], + [0x118B2, 0x118D2], + [0x118B3, 0x118D3], + [0x118B4, 0x118D4], + [0x118B5, 0x118D5], + [0x118B6, 0x118D6], + [0x118B7, 0x118D7], + [0x118B8, 0x118D8], + [0x118B9, 0x118D9], + [0x118BA, 0x118DA], + [0x118BB, 0x118DB], + [0x118BC, 0x118DC], + [0x118BD, 0x118DD], + [0x118BE, 0x118DE], + [0x118BF, 0x118DF], + [0x16E40, 0x16E60], + [0x16E41, 0x16E61], + [0x16E42, 0x16E62], + [0x16E43, 0x16E63], + [0x16E44, 0x16E64], + [0x16E45, 0x16E65], + [0x16E46, 0x16E66], + [0x16E47, 0x16E67], + [0x16E48, 0x16E68], + [0x16E49, 0x16E69], + [0x16E4A, 0x16E6A], + [0x16E4B, 0x16E6B], + [0x16E4C, 0x16E6C], + [0x16E4D, 0x16E6D], + [0x16E4E, 0x16E6E], + [0x16E4F, 0x16E6F], + [0x16E50, 0x16E70], + [0x16E51, 0x16E71], + [0x16E52, 0x16E72], + [0x16E53, 0x16E73], + [0x16E54, 0x16E74], + [0x16E55, 0x16E75], + [0x16E56, 0x16E76], + [0x16E57, 0x16E77], + [0x16E58, 0x16E78], + [0x16E59, 0x16E79], + [0x16E5A, 0x16E7A], + [0x16E5B, 0x16E7B], + [0x16E5C, 0x16E7C], + [0x16E5D, 0x16E7D], + [0x16E5E, 0x16E7E], + [0x16E5F, 0x16E7F], + [0x16EA0, 0x16EBB], + [0x16EA1, 0x16EBC], + [0x16EA2, 0x16EBD], + [0x16EA3, 0x16EBE], + [0x16EA4, 0x16EBF], + [0x16EA5, 0x16EC0], + [0x16EA6, 0x16EC1], + [0x16EA7, 0x16EC2], + [0x16EA8, 0x16EC3], + [0x16EA9, 0x16EC4], + [0x16EAA, 0x16EC5], + [0x16EAB, 0x16EC6], + [0x16EAC, 0x16EC7], + [0x16EAD, 0x16EC8], + [0x16EAE, 0x16EC9], + [0x16EAF, 0x16ECA], + [0x16EB0, 0x16ECB], + [0x16EB1, 0x16ECC], + [0x16EB2, 0x16ECD], + [0x16EB3, 0x16ECE], + [0x16EB4, 0x16ECF], + [0x16EB5, 0x16ED0], + [0x16EB6, 0x16ED1], + [0x16EB7, 0x16ED2], + [0x16EB8, 0x16ED3], + [0x1E900, 0x1E922], + [0x1E901, 0x1E923], + [0x1E902, 0x1E924], + [0x1E903, 0x1E925], + [0x1E904, 0x1E926], + [0x1E905, 0x1E927], + [0x1E906, 0x1E928], + [0x1E907, 0x1E929], + [0x1E908, 0x1E92A], + [0x1E909, 0x1E92B], + [0x1E90A, 0x1E92C], + [0x1E90B, 0x1E92D], + [0x1E90C, 0x1E92E], + [0x1E90D, 0x1E92F], + [0x1E90E, 0x1E930], + [0x1E90F, 0x1E931], + [0x1E910, 0x1E932], + [0x1E911, 0x1E933], + [0x1E912, 0x1E934], + [0x1E913, 0x1E935], + [0x1E914, 0x1E936], + [0x1E915, 0x1E937], + [0x1E916, 0x1E938], + [0x1E917, 0x1E939], + [0x1E918, 0x1E93A], + [0x1E919, 0x1E93B], + [0x1E91A, 0x1E93C], + [0x1E91B, 0x1E93D], + [0x1E91C, 0x1E93E], + [0x1E91D, 0x1E93F], + [0x1E91E, 0x1E940], + [0x1E91F, 0x1E941], + [0x1E920, 0x1E942], + [0x1E921, 0x1E943] +]); diff --git a/tools/ui/node_modules/regexpu-core/data/iu-mappings.js b/tools/ui/node_modules/regexpu-core/data/iu-mappings.js new file mode 100644 index 0000000000000000000000000000000000000000..600f4af224b95652e25c22a3c85435efc84ddd10 --- /dev/null +++ b/tools/ui/node_modules/regexpu-core/data/iu-mappings.js @@ -0,0 +1,756 @@ +module.exports = new Map([ + [0x4B, 0x212A], + [0x53, 0x17F], + [0x6B, 0x212A], + [0x73, 0x17F], + [0xB5, 0x39C], + [0xC5, 0x212B], + [0xDF, 0x1E9E], + [0xE5, 0x212B], + [0x17F, 0x53], + [0x1C4, 0x1C5], + [0x1C5, 0x1C4], + [0x1C7, 0x1C8], + [0x1C8, 0x1C7], + [0x1CA, 0x1CB], + [0x1CB, 0x1CA], + [0x1F1, 0x1F2], + [0x1F2, 0x1F1], + [0x345, 0x1FBE], + [0x390, 0x1FD3], + [0x392, 0x3D0], + [0x395, 0x3F5], + [0x398, 0x3F4], + [0x399, 0x1FBE], + [0x39A, 0x3F0], + [0x39C, 0xB5], + [0x3A0, 0x3D6], + [0x3A1, 0x3F1], + [0x3A3, 0x3C2], + [0x3A6, 0x3D5], + [0x3A9, 0x2126], + [0x3B0, 0x1FE3], + [0x3B8, 0x3F4], + [0x3C2, 0x3A3], + [0x3C9, 0x2126], + [0x3D0, 0x392], + [0x3D1, 0x3F4], + [0x3D5, 0x3A6], + [0x3D6, 0x3A0], + [0x3F0, 0x39A], + [0x3F1, 0x3A1], + [0x3F4, [ + 0x398, + 0x3D1, + 0x3B8 + ]], + [0x3F5, 0x395], + [0x412, 0x1C80], + [0x414, 0x1C81], + [0x41E, 0x1C82], + [0x421, 0x1C83], + [0x422, 0x1C85], + [0x42A, 0x1C86], + [0x462, 0x1C87], + [0x1C80, 0x412], + [0x1C81, 0x414], + [0x1C82, 0x41E], + [0x1C83, 0x421], + [0x1C84, 0x1C85], + [0x1C85, [ + 0x422, + 0x1C84 + ]], + [0x1C86, 0x42A], + [0x1C87, 0x462], + [0x1C88, 0xA64A], + [0x1E60, 0x1E9B], + [0x1E9B, 0x1E60], + [0x1E9E, 0xDF], + [0x1F80, 0x1F88], + [0x1F81, 0x1F89], + [0x1F82, 0x1F8A], + [0x1F83, 0x1F8B], + [0x1F84, 0x1F8C], + [0x1F85, 0x1F8D], + [0x1F86, 0x1F8E], + [0x1F87, 0x1F8F], + [0x1F88, 0x1F80], + [0x1F89, 0x1F81], + [0x1F8A, 0x1F82], + [0x1F8B, 0x1F83], + [0x1F8C, 0x1F84], + [0x1F8D, 0x1F85], + [0x1F8E, 0x1F86], + [0x1F8F, 0x1F87], + [0x1F90, 0x1F98], + [0x1F91, 0x1F99], + [0x1F92, 0x1F9A], + [0x1F93, 0x1F9B], + [0x1F94, 0x1F9C], + [0x1F95, 0x1F9D], + [0x1F96, 0x1F9E], + [0x1F97, 0x1F9F], + [0x1F98, 0x1F90], + [0x1F99, 0x1F91], + [0x1F9A, 0x1F92], + [0x1F9B, 0x1F93], + [0x1F9C, 0x1F94], + [0x1F9D, 0x1F95], + [0x1F9E, 0x1F96], + [0x1F9F, 0x1F97], + [0x1FA0, 0x1FA8], + [0x1FA1, 0x1FA9], + [0x1FA2, 0x1FAA], + [0x1FA3, 0x1FAB], + [0x1FA4, 0x1FAC], + [0x1FA5, 0x1FAD], + [0x1FA6, 0x1FAE], + [0x1FA7, 0x1FAF], + [0x1FA8, 0x1FA0], + [0x1FA9, 0x1FA1], + [0x1FAA, 0x1FA2], + [0x1FAB, 0x1FA3], + [0x1FAC, 0x1FA4], + [0x1FAD, 0x1FA5], + [0x1FAE, 0x1FA6], + [0x1FAF, 0x1FA7], + [0x1FB3, 0x1FBC], + [0x1FBC, 0x1FB3], + [0x1FBE, [ + 0x345, + 0x399 + ]], + [0x1FC3, 0x1FCC], + [0x1FCC, 0x1FC3], + [0x1FD3, 0x390], + [0x1FE3, 0x3B0], + [0x1FF3, 0x1FFC], + [0x1FFC, 0x1FF3], + [0x2126, [ + 0x3A9, + 0x3C9 + ]], + [0x212A, 0x4B], + [0x212B, [ + 0xC5, + 0xE5 + ]], + [0xA64A, 0x1C88], + [0xFB05, 0xFB06], + [0xFB06, 0xFB05], + [0x10400, 0x10428], + [0x10401, 0x10429], + [0x10402, 0x1042A], + [0x10403, 0x1042B], + [0x10404, 0x1042C], + [0x10405, 0x1042D], + [0x10406, 0x1042E], + [0x10407, 0x1042F], + [0x10408, 0x10430], + [0x10409, 0x10431], + [0x1040A, 0x10432], + [0x1040B, 0x10433], + [0x1040C, 0x10434], + [0x1040D, 0x10435], + [0x1040E, 0x10436], + [0x1040F, 0x10437], + [0x10410, 0x10438], + [0x10411, 0x10439], + [0x10412, 0x1043A], + [0x10413, 0x1043B], + [0x10414, 0x1043C], + [0x10415, 0x1043D], + [0x10416, 0x1043E], + [0x10417, 0x1043F], + [0x10418, 0x10440], + [0x10419, 0x10441], + [0x1041A, 0x10442], + [0x1041B, 0x10443], + [0x1041C, 0x10444], + [0x1041D, 0x10445], + [0x1041E, 0x10446], + [0x1041F, 0x10447], + [0x10420, 0x10448], + [0x10421, 0x10449], + [0x10422, 0x1044A], + [0x10423, 0x1044B], + [0x10424, 0x1044C], + [0x10425, 0x1044D], + [0x10426, 0x1044E], + [0x10427, 0x1044F], + [0x10428, 0x10400], + [0x10429, 0x10401], + [0x1042A, 0x10402], + [0x1042B, 0x10403], + [0x1042C, 0x10404], + [0x1042D, 0x10405], + [0x1042E, 0x10406], + [0x1042F, 0x10407], + [0x10430, 0x10408], + [0x10431, 0x10409], + [0x10432, 0x1040A], + [0x10433, 0x1040B], + [0x10434, 0x1040C], + [0x10435, 0x1040D], + [0x10436, 0x1040E], + [0x10437, 0x1040F], + [0x10438, 0x10410], + [0x10439, 0x10411], + [0x1043A, 0x10412], + [0x1043B, 0x10413], + [0x1043C, 0x10414], + [0x1043D, 0x10415], + [0x1043E, 0x10416], + [0x1043F, 0x10417], + [0x10440, 0x10418], + [0x10441, 0x10419], + [0x10442, 0x1041A], + [0x10443, 0x1041B], + [0x10444, 0x1041C], + [0x10445, 0x1041D], + [0x10446, 0x1041E], + [0x10447, 0x1041F], + [0x10448, 0x10420], + [0x10449, 0x10421], + [0x1044A, 0x10422], + [0x1044B, 0x10423], + [0x1044C, 0x10424], + [0x1044D, 0x10425], + [0x1044E, 0x10426], + [0x1044F, 0x10427], + [0x104B0, 0x104D8], + [0x104B1, 0x104D9], + [0x104B2, 0x104DA], + [0x104B3, 0x104DB], + [0x104B4, 0x104DC], + [0x104B5, 0x104DD], + [0x104B6, 0x104DE], + [0x104B7, 0x104DF], + [0x104B8, 0x104E0], + [0x104B9, 0x104E1], + [0x104BA, 0x104E2], + [0x104BB, 0x104E3], + [0x104BC, 0x104E4], + [0x104BD, 0x104E5], + [0x104BE, 0x104E6], + [0x104BF, 0x104E7], + [0x104C0, 0x104E8], + [0x104C1, 0x104E9], + [0x104C2, 0x104EA], + [0x104C3, 0x104EB], + [0x104C4, 0x104EC], + [0x104C5, 0x104ED], + [0x104C6, 0x104EE], + [0x104C7, 0x104EF], + [0x104C8, 0x104F0], + [0x104C9, 0x104F1], + [0x104CA, 0x104F2], + [0x104CB, 0x104F3], + [0x104CC, 0x104F4], + [0x104CD, 0x104F5], + [0x104CE, 0x104F6], + [0x104CF, 0x104F7], + [0x104D0, 0x104F8], + [0x104D1, 0x104F9], + [0x104D2, 0x104FA], + [0x104D3, 0x104FB], + [0x104D8, 0x104B0], + [0x104D9, 0x104B1], + [0x104DA, 0x104B2], + [0x104DB, 0x104B3], + [0x104DC, 0x104B4], + [0x104DD, 0x104B5], + [0x104DE, 0x104B6], + [0x104DF, 0x104B7], + [0x104E0, 0x104B8], + [0x104E1, 0x104B9], + [0x104E2, 0x104BA], + [0x104E3, 0x104BB], + [0x104E4, 0x104BC], + [0x104E5, 0x104BD], + [0x104E6, 0x104BE], + [0x104E7, 0x104BF], + [0x104E8, 0x104C0], + [0x104E9, 0x104C1], + [0x104EA, 0x104C2], + [0x104EB, 0x104C3], + [0x104EC, 0x104C4], + [0x104ED, 0x104C5], + [0x104EE, 0x104C6], + [0x104EF, 0x104C7], + [0x104F0, 0x104C8], + [0x104F1, 0x104C9], + [0x104F2, 0x104CA], + [0x104F3, 0x104CB], + [0x104F4, 0x104CC], + [0x104F5, 0x104CD], + [0x104F6, 0x104CE], + [0x104F7, 0x104CF], + [0x104F8, 0x104D0], + [0x104F9, 0x104D1], + [0x104FA, 0x104D2], + [0x104FB, 0x104D3], + [0x10570, 0x10597], + [0x10571, 0x10598], + [0x10572, 0x10599], + [0x10573, 0x1059A], + [0x10574, 0x1059B], + [0x10575, 0x1059C], + [0x10576, 0x1059D], + [0x10577, 0x1059E], + [0x10578, 0x1059F], + [0x10579, 0x105A0], + [0x1057A, 0x105A1], + [0x1057C, 0x105A3], + [0x1057D, 0x105A4], + [0x1057E, 0x105A5], + [0x1057F, 0x105A6], + [0x10580, 0x105A7], + [0x10581, 0x105A8], + [0x10582, 0x105A9], + [0x10583, 0x105AA], + [0x10584, 0x105AB], + [0x10585, 0x105AC], + [0x10586, 0x105AD], + [0x10587, 0x105AE], + [0x10588, 0x105AF], + [0x10589, 0x105B0], + [0x1058A, 0x105B1], + [0x1058C, 0x105B3], + [0x1058D, 0x105B4], + [0x1058E, 0x105B5], + [0x1058F, 0x105B6], + [0x10590, 0x105B7], + [0x10591, 0x105B8], + [0x10592, 0x105B9], + [0x10594, 0x105BB], + [0x10595, 0x105BC], + [0x10597, 0x10570], + [0x10598, 0x10571], + [0x10599, 0x10572], + [0x1059A, 0x10573], + [0x1059B, 0x10574], + [0x1059C, 0x10575], + [0x1059D, 0x10576], + [0x1059E, 0x10577], + [0x1059F, 0x10578], + [0x105A0, 0x10579], + [0x105A1, 0x1057A], + [0x105A3, 0x1057C], + [0x105A4, 0x1057D], + [0x105A5, 0x1057E], + [0x105A6, 0x1057F], + [0x105A7, 0x10580], + [0x105A8, 0x10581], + [0x105A9, 0x10582], + [0x105AA, 0x10583], + [0x105AB, 0x10584], + [0x105AC, 0x10585], + [0x105AD, 0x10586], + [0x105AE, 0x10587], + [0x105AF, 0x10588], + [0x105B0, 0x10589], + [0x105B1, 0x1058A], + [0x105B3, 0x1058C], + [0x105B4, 0x1058D], + [0x105B5, 0x1058E], + [0x105B6, 0x1058F], + [0x105B7, 0x10590], + [0x105B8, 0x10591], + [0x105B9, 0x10592], + [0x105BB, 0x10594], + [0x105BC, 0x10595], + [0x10C80, 0x10CC0], + [0x10C81, 0x10CC1], + [0x10C82, 0x10CC2], + [0x10C83, 0x10CC3], + [0x10C84, 0x10CC4], + [0x10C85, 0x10CC5], + [0x10C86, 0x10CC6], + [0x10C87, 0x10CC7], + [0x10C88, 0x10CC8], + [0x10C89, 0x10CC9], + [0x10C8A, 0x10CCA], + [0x10C8B, 0x10CCB], + [0x10C8C, 0x10CCC], + [0x10C8D, 0x10CCD], + [0x10C8E, 0x10CCE], + [0x10C8F, 0x10CCF], + [0x10C90, 0x10CD0], + [0x10C91, 0x10CD1], + [0x10C92, 0x10CD2], + [0x10C93, 0x10CD3], + [0x10C94, 0x10CD4], + [0x10C95, 0x10CD5], + [0x10C96, 0x10CD6], + [0x10C97, 0x10CD7], + [0x10C98, 0x10CD8], + [0x10C99, 0x10CD9], + [0x10C9A, 0x10CDA], + [0x10C9B, 0x10CDB], + [0x10C9C, 0x10CDC], + [0x10C9D, 0x10CDD], + [0x10C9E, 0x10CDE], + [0x10C9F, 0x10CDF], + [0x10CA0, 0x10CE0], + [0x10CA1, 0x10CE1], + [0x10CA2, 0x10CE2], + [0x10CA3, 0x10CE3], + [0x10CA4, 0x10CE4], + [0x10CA5, 0x10CE5], + [0x10CA6, 0x10CE6], + [0x10CA7, 0x10CE7], + [0x10CA8, 0x10CE8], + [0x10CA9, 0x10CE9], + [0x10CAA, 0x10CEA], + [0x10CAB, 0x10CEB], + [0x10CAC, 0x10CEC], + [0x10CAD, 0x10CED], + [0x10CAE, 0x10CEE], + [0x10CAF, 0x10CEF], + [0x10CB0, 0x10CF0], + [0x10CB1, 0x10CF1], + [0x10CB2, 0x10CF2], + [0x10CC0, 0x10C80], + [0x10CC1, 0x10C81], + [0x10CC2, 0x10C82], + [0x10CC3, 0x10C83], + [0x10CC4, 0x10C84], + [0x10CC5, 0x10C85], + [0x10CC6, 0x10C86], + [0x10CC7, 0x10C87], + [0x10CC8, 0x10C88], + [0x10CC9, 0x10C89], + [0x10CCA, 0x10C8A], + [0x10CCB, 0x10C8B], + [0x10CCC, 0x10C8C], + [0x10CCD, 0x10C8D], + [0x10CCE, 0x10C8E], + [0x10CCF, 0x10C8F], + [0x10CD0, 0x10C90], + [0x10CD1, 0x10C91], + [0x10CD2, 0x10C92], + [0x10CD3, 0x10C93], + [0x10CD4, 0x10C94], + [0x10CD5, 0x10C95], + [0x10CD6, 0x10C96], + [0x10CD7, 0x10C97], + [0x10CD8, 0x10C98], + [0x10CD9, 0x10C99], + [0x10CDA, 0x10C9A], + [0x10CDB, 0x10C9B], + [0x10CDC, 0x10C9C], + [0x10CDD, 0x10C9D], + [0x10CDE, 0x10C9E], + [0x10CDF, 0x10C9F], + [0x10CE0, 0x10CA0], + [0x10CE1, 0x10CA1], + [0x10CE2, 0x10CA2], + [0x10CE3, 0x10CA3], + [0x10CE4, 0x10CA4], + [0x10CE5, 0x10CA5], + [0x10CE6, 0x10CA6], + [0x10CE7, 0x10CA7], + [0x10CE8, 0x10CA8], + [0x10CE9, 0x10CA9], + [0x10CEA, 0x10CAA], + [0x10CEB, 0x10CAB], + [0x10CEC, 0x10CAC], + [0x10CED, 0x10CAD], + [0x10CEE, 0x10CAE], + [0x10CEF, 0x10CAF], + [0x10CF0, 0x10CB0], + [0x10CF1, 0x10CB1], + [0x10CF2, 0x10CB2], + [0x10D50, 0x10D70], + [0x10D51, 0x10D71], + [0x10D52, 0x10D72], + [0x10D53, 0x10D73], + [0x10D54, 0x10D74], + [0x10D55, 0x10D75], + [0x10D56, 0x10D76], + [0x10D57, 0x10D77], + [0x10D58, 0x10D78], + [0x10D59, 0x10D79], + [0x10D5A, 0x10D7A], + [0x10D5B, 0x10D7B], + [0x10D5C, 0x10D7C], + [0x10D5D, 0x10D7D], + [0x10D5E, 0x10D7E], + [0x10D5F, 0x10D7F], + [0x10D60, 0x10D80], + [0x10D61, 0x10D81], + [0x10D62, 0x10D82], + [0x10D63, 0x10D83], + [0x10D64, 0x10D84], + [0x10D65, 0x10D85], + [0x10D70, 0x10D50], + [0x10D71, 0x10D51], + [0x10D72, 0x10D52], + [0x10D73, 0x10D53], + [0x10D74, 0x10D54], + [0x10D75, 0x10D55], + [0x10D76, 0x10D56], + [0x10D77, 0x10D57], + [0x10D78, 0x10D58], + [0x10D79, 0x10D59], + [0x10D7A, 0x10D5A], + [0x10D7B, 0x10D5B], + [0x10D7C, 0x10D5C], + [0x10D7D, 0x10D5D], + [0x10D7E, 0x10D5E], + [0x10D7F, 0x10D5F], + [0x10D80, 0x10D60], + [0x10D81, 0x10D61], + [0x10D82, 0x10D62], + [0x10D83, 0x10D63], + [0x10D84, 0x10D64], + [0x10D85, 0x10D65], + [0x118A0, 0x118C0], + [0x118A1, 0x118C1], + [0x118A2, 0x118C2], + [0x118A3, 0x118C3], + [0x118A4, 0x118C4], + [0x118A5, 0x118C5], + [0x118A6, 0x118C6], + [0x118A7, 0x118C7], + [0x118A8, 0x118C8], + [0x118A9, 0x118C9], + [0x118AA, 0x118CA], + [0x118AB, 0x118CB], + [0x118AC, 0x118CC], + [0x118AD, 0x118CD], + [0x118AE, 0x118CE], + [0x118AF, 0x118CF], + [0x118B0, 0x118D0], + [0x118B1, 0x118D1], + [0x118B2, 0x118D2], + [0x118B3, 0x118D3], + [0x118B4, 0x118D4], + [0x118B5, 0x118D5], + [0x118B6, 0x118D6], + [0x118B7, 0x118D7], + [0x118B8, 0x118D8], + [0x118B9, 0x118D9], + [0x118BA, 0x118DA], + [0x118BB, 0x118DB], + [0x118BC, 0x118DC], + [0x118BD, 0x118DD], + [0x118BE, 0x118DE], + [0x118BF, 0x118DF], + [0x118C0, 0x118A0], + [0x118C1, 0x118A1], + [0x118C2, 0x118A2], + [0x118C3, 0x118A3], + [0x118C4, 0x118A4], + [0x118C5, 0x118A5], + [0x118C6, 0x118A6], + [0x118C7, 0x118A7], + [0x118C8, 0x118A8], + [0x118C9, 0x118A9], + [0x118CA, 0x118AA], + [0x118CB, 0x118AB], + [0x118CC, 0x118AC], + [0x118CD, 0x118AD], + [0x118CE, 0x118AE], + [0x118CF, 0x118AF], + [0x118D0, 0x118B0], + [0x118D1, 0x118B1], + [0x118D2, 0x118B2], + [0x118D3, 0x118B3], + [0x118D4, 0x118B4], + [0x118D5, 0x118B5], + [0x118D6, 0x118B6], + [0x118D7, 0x118B7], + [0x118D8, 0x118B8], + [0x118D9, 0x118B9], + [0x118DA, 0x118BA], + [0x118DB, 0x118BB], + [0x118DC, 0x118BC], + [0x118DD, 0x118BD], + [0x118DE, 0x118BE], + [0x118DF, 0x118BF], + [0x16E40, 0x16E60], + [0x16E41, 0x16E61], + [0x16E42, 0x16E62], + [0x16E43, 0x16E63], + [0x16E44, 0x16E64], + [0x16E45, 0x16E65], + [0x16E46, 0x16E66], + [0x16E47, 0x16E67], + [0x16E48, 0x16E68], + [0x16E49, 0x16E69], + [0x16E4A, 0x16E6A], + [0x16E4B, 0x16E6B], + [0x16E4C, 0x16E6C], + [0x16E4D, 0x16E6D], + [0x16E4E, 0x16E6E], + [0x16E4F, 0x16E6F], + [0x16E50, 0x16E70], + [0x16E51, 0x16E71], + [0x16E52, 0x16E72], + [0x16E53, 0x16E73], + [0x16E54, 0x16E74], + [0x16E55, 0x16E75], + [0x16E56, 0x16E76], + [0x16E57, 0x16E77], + [0x16E58, 0x16E78], + [0x16E59, 0x16E79], + [0x16E5A, 0x16E7A], + [0x16E5B, 0x16E7B], + [0x16E5C, 0x16E7C], + [0x16E5D, 0x16E7D], + [0x16E5E, 0x16E7E], + [0x16E5F, 0x16E7F], + [0x16E60, 0x16E40], + [0x16E61, 0x16E41], + [0x16E62, 0x16E42], + [0x16E63, 0x16E43], + [0x16E64, 0x16E44], + [0x16E65, 0x16E45], + [0x16E66, 0x16E46], + [0x16E67, 0x16E47], + [0x16E68, 0x16E48], + [0x16E69, 0x16E49], + [0x16E6A, 0x16E4A], + [0x16E6B, 0x16E4B], + [0x16E6C, 0x16E4C], + [0x16E6D, 0x16E4D], + [0x16E6E, 0x16E4E], + [0x16E6F, 0x16E4F], + [0x16E70, 0x16E50], + [0x16E71, 0x16E51], + [0x16E72, 0x16E52], + [0x16E73, 0x16E53], + [0x16E74, 0x16E54], + [0x16E75, 0x16E55], + [0x16E76, 0x16E56], + [0x16E77, 0x16E57], + [0x16E78, 0x16E58], + [0x16E79, 0x16E59], + [0x16E7A, 0x16E5A], + [0x16E7B, 0x16E5B], + [0x16E7C, 0x16E5C], + [0x16E7D, 0x16E5D], + [0x16E7E, 0x16E5E], + [0x16E7F, 0x16E5F], + [0x16EA0, 0x16EBB], + [0x16EA1, 0x16EBC], + [0x16EA2, 0x16EBD], + [0x16EA3, 0x16EBE], + [0x16EA4, 0x16EBF], + [0x16EA5, 0x16EC0], + [0x16EA6, 0x16EC1], + [0x16EA7, 0x16EC2], + [0x16EA8, 0x16EC3], + [0x16EA9, 0x16EC4], + [0x16EAA, 0x16EC5], + [0x16EAB, 0x16EC6], + [0x16EAC, 0x16EC7], + [0x16EAD, 0x16EC8], + [0x16EAE, 0x16EC9], + [0x16EAF, 0x16ECA], + [0x16EB0, 0x16ECB], + [0x16EB1, 0x16ECC], + [0x16EB2, 0x16ECD], + [0x16EB3, 0x16ECE], + [0x16EB4, 0x16ECF], + [0x16EB5, 0x16ED0], + [0x16EB6, 0x16ED1], + [0x16EB7, 0x16ED2], + [0x16EB8, 0x16ED3], + [0x16EBB, 0x16EA0], + [0x16EBC, 0x16EA1], + [0x16EBD, 0x16EA2], + [0x16EBE, 0x16EA3], + [0x16EBF, 0x16EA4], + [0x16EC0, 0x16EA5], + [0x16EC1, 0x16EA6], + [0x16EC2, 0x16EA7], + [0x16EC3, 0x16EA8], + [0x16EC4, 0x16EA9], + [0x16EC5, 0x16EAA], + [0x16EC6, 0x16EAB], + [0x16EC7, 0x16EAC], + [0x16EC8, 0x16EAD], + [0x16EC9, 0x16EAE], + [0x16ECA, 0x16EAF], + [0x16ECB, 0x16EB0], + [0x16ECC, 0x16EB1], + [0x16ECD, 0x16EB2], + [0x16ECE, 0x16EB3], + [0x16ECF, 0x16EB4], + [0x16ED0, 0x16EB5], + [0x16ED1, 0x16EB6], + [0x16ED2, 0x16EB7], + [0x16ED3, 0x16EB8], + [0x1E900, 0x1E922], + [0x1E901, 0x1E923], + [0x1E902, 0x1E924], + [0x1E903, 0x1E925], + [0x1E904, 0x1E926], + [0x1E905, 0x1E927], + [0x1E906, 0x1E928], + [0x1E907, 0x1E929], + [0x1E908, 0x1E92A], + [0x1E909, 0x1E92B], + [0x1E90A, 0x1E92C], + [0x1E90B, 0x1E92D], + [0x1E90C, 0x1E92E], + [0x1E90D, 0x1E92F], + [0x1E90E, 0x1E930], + [0x1E90F, 0x1E931], + [0x1E910, 0x1E932], + [0x1E911, 0x1E933], + [0x1E912, 0x1E934], + [0x1E913, 0x1E935], + [0x1E914, 0x1E936], + [0x1E915, 0x1E937], + [0x1E916, 0x1E938], + [0x1E917, 0x1E939], + [0x1E918, 0x1E93A], + [0x1E919, 0x1E93B], + [0x1E91A, 0x1E93C], + [0x1E91B, 0x1E93D], + [0x1E91C, 0x1E93E], + [0x1E91D, 0x1E93F], + [0x1E91E, 0x1E940], + [0x1E91F, 0x1E941], + [0x1E920, 0x1E942], + [0x1E921, 0x1E943], + [0x1E922, 0x1E900], + [0x1E923, 0x1E901], + [0x1E924, 0x1E902], + [0x1E925, 0x1E903], + [0x1E926, 0x1E904], + [0x1E927, 0x1E905], + [0x1E928, 0x1E906], + [0x1E929, 0x1E907], + [0x1E92A, 0x1E908], + [0x1E92B, 0x1E909], + [0x1E92C, 0x1E90A], + [0x1E92D, 0x1E90B], + [0x1E92E, 0x1E90C], + [0x1E92F, 0x1E90D], + [0x1E930, 0x1E90E], + [0x1E931, 0x1E90F], + [0x1E932, 0x1E910], + [0x1E933, 0x1E911], + [0x1E934, 0x1E912], + [0x1E935, 0x1E913], + [0x1E936, 0x1E914], + [0x1E937, 0x1E915], + [0x1E938, 0x1E916], + [0x1E939, 0x1E917], + [0x1E93A, 0x1E918], + [0x1E93B, 0x1E919], + [0x1E93C, 0x1E91A], + [0x1E93D, 0x1E91B], + [0x1E93E, 0x1E91C], + [0x1E93F, 0x1E91D], + [0x1E940, 0x1E91E], + [0x1E941, 0x1E91F], + [0x1E942, 0x1E920], + [0x1E943, 0x1E921] +]); diff --git a/tools/ui/node_modules/regexpu-core/package.json b/tools/ui/node_modules/regexpu-core/package.json new file mode 100644 index 0000000000000000000000000000000000000000..a828a79e5335ddeab053e7e72580081164740317 --- /dev/null +++ b/tools/ui/node_modules/regexpu-core/package.json @@ -0,0 +1,67 @@ +{ + "name": "regexpu-core", + "version": "6.4.0", + "description": "regexpu’s core functionality (i.e. `rewritePattern(pattern, flag)`), capable of translating ES6 Unicode regular expressions to ES5.", + "homepage": "https://mths.be/regexpu", + "main": "rewrite-pattern.js", + "engines": { + "node": ">=4" + }, + "keywords": [ + "codegen", + "desugaring", + "ecmascript", + "es5", + "es6", + "harmony", + "javascript", + "refactoring", + "regex", + "regexp", + "regular expressions", + "rewriting", + "syntax", + "transformation", + "transpile", + "transpiler", + "unicode" + ], + "license": "MIT", + "author": { + "name": "Mathias Bynens", + "url": "https://mathiasbynens.be/" + }, + "repository": { + "type": "git", + "url": "https://github.com/mathiasbynens/regexpu-core.git" + }, + "bugs": "https://github.com/mathiasbynens/regexpu-core/issues", + "files": [ + "LICENSE-MIT.txt", + "rewrite-pattern.js", + "rewrite-pattern.d.ts", + "data/all-characters.js", + "data/character-class-escape-sets.js", + "data/i-bmp-mappings.js", + "data/iu-foldings.js", + "data/iu-mappings.js" + ], + "scripts": { + "build": "node scripts/index.js", + "test": "node --test tests/tests.js", + "test-node6": "mocha tests", + "cover": "NODE_V8_COVERAGE=coverage node --test --experimental-test-coverage tests/tests.js" + }, + "dependencies": { + "regenerate": "^1.4.2", + "regenerate-unicode-properties": "^10.2.2", + "regjsgen": "^0.8.0", + "regjsparser": "^0.13.0", + "unicode-match-property-ecmascript": "^2.0.0", + "unicode-match-property-value-ecmascript": "^2.2.1" + }, + "devDependencies": { + "jsesc": "^3.0.2", + "@unicode/unicode-17.0.0": "^1.6.12" + } +} diff --git a/tools/ui/node_modules/regexpu-core/rewrite-pattern.d.ts b/tools/ui/node_modules/regexpu-core/rewrite-pattern.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5c2cc056c319aede616787a9f5b681220a0f497d --- /dev/null +++ b/tools/ui/node_modules/regexpu-core/rewrite-pattern.d.ts @@ -0,0 +1,17 @@ +declare module "regexpu-core" { + export type RegexpuOptions = { + unicodeFlag?: "transform" | false; + unicodeSetsFlag?: "transform" | false; + dotAllFlag?: "transform" | false; + unicodePropertyEscapes?: "transform" | false; + namedGroups?: "transform" | false; + onNamedGroup?: (name: string, index: number) => void; + modifiers?: "transform" | false | "parse"; + onNewFlags?: (flags: string) => void; + }; + export default function rewritePattern( + pattern: string, + flags: string, + options: RegexpuOptions | undefined + ): string; +} diff --git a/tools/ui/node_modules/regexpu-core/rewrite-pattern.js b/tools/ui/node_modules/regexpu-core/rewrite-pattern.js new file mode 100644 index 0000000000000000000000000000000000000000..02c52c2faa10712dba75e09ee7aa6b9270aa85ba --- /dev/null +++ b/tools/ui/node_modules/regexpu-core/rewrite-pattern.js @@ -0,0 +1,1003 @@ +'use strict'; + +const generate = require('regjsgen').generate; +const parse = require('regjsparser').parse; +const regenerate = require('regenerate'); +const unicodeMatchProperty = require('unicode-match-property-ecmascript'); +const unicodeMatchPropertyValue = require('unicode-match-property-value-ecmascript'); +const iuMappings = require('./data/iu-mappings.js'); +const iBMPMappings = require('./data/i-bmp-mappings.js'); +const iuFoldings = require('./data/iu-foldings.js'); +const ESCAPE_SETS = require('./data/character-class-escape-sets.js'); +const { UNICODE_SET, UNICODE_IV_SET } = require('./data/all-characters.js'); + +function flatMap(array, callback) { + const result = []; + array.forEach(item => { + const res = callback(item); + if (Array.isArray(res)) { + result.push.apply(result, res); + } else { + result.push(res); + } + }); + return result; +} + +function regenerateContainsAstral(regenerateData) { + const data = regenerateData.data; + return data.length >= 1 && data[data.length - 1] >= 0x10000; +} + +// https://tc39.es/ecma262/#prod-SyntaxCharacter +const SYNTAX_CHARS = /[\\^$.*+?()[\]{}|]/g; + +const ASTRAL_SET = regenerate().addRange(0x10000, 0x10FFFF); + +const NEWLINE_SET = regenerate().add( + // `LineTerminator`s (https://mths.be/es6#sec-line-terminators): + 0x000A, // Line Feed + 0x000D, // Carriage Return + 0x2028, // Line Separator + 0x2029 // Paragraph Separator +); + +// Prepare a Regenerate set containing all code points that are supposed to be +// matched by `/./u`. https://mths.be/es6#sec-atom +const DOT_SET_UNICODE = UNICODE_SET.clone() // all Unicode code points + .remove(NEWLINE_SET); + +const getCharacterClassEscapeSet = (character, unicode, ignoreCase, shouldApplySCF) => { + if (unicode) { + if (ignoreCase) { + const result = ESCAPE_SETS.UNICODE_IGNORE_CASE.get(character); + if (shouldApplySCF) { + return ESCAPE_SETS.UNICODESET_IGNORE_CASE.get(character); + } else { + return result; + } + } + return ESCAPE_SETS.UNICODE.get(character); + } + return ESCAPE_SETS.REGULAR.get(character); +}; + +const getUnicodeDotSet = (dotAll) => { + return dotAll ? UNICODE_SET : DOT_SET_UNICODE; +}; + +const getUnicodePropertyValueSet = (property, value) => { + const path = value ? + `${ property }/${ value }` : + `Binary_Property/${ property }`; + try { + return require(`regenerate-unicode-properties/${ path }.js`); + } catch (exception) { + throw new Error( + `Failed to recognize value \`${ value }\` for property ` + + `\`${ property }\`.` + ); + } +}; + +const handleLoneUnicodePropertyNameOrValue = (value) => { + // It could be a `General_Category` value or a binary property. + // Note: `unicodeMatchPropertyValue` throws on invalid values. + try { + const property = 'General_Category'; + const category = unicodeMatchPropertyValue(property, value); + return getUnicodePropertyValueSet(property, category); + } catch (exception) {} + // It’s not a `General_Category` value, so check if it’s a property + // of strings. + try { + return getUnicodePropertyValueSet('Property_of_Strings', value); + } catch (exception) {} + // Lastly, check if it’s a binary property of single code points. + // Note: `unicodeMatchProperty` throws on invalid properties. + const property = unicodeMatchProperty(value); + return getUnicodePropertyValueSet(property); +}; + +const getUnicodePropertyEscapeSet = (value, isNegative, isUnicodeSetIgnoreCase) => { + const parts = value.split('='); + const firstPart = parts[0]; + let set; + if (parts.length == 1) { + set = handleLoneUnicodePropertyNameOrValue(firstPart); + } else { + // The pattern consists of two parts, i.e. `Property=Value`. + const property = unicodeMatchProperty(firstPart); + const value = unicodeMatchPropertyValue(property, parts[1]); + set = getUnicodePropertyValueSet(property, value); + } + if (isNegative) { + if (set.strings) { + throw new Error('Cannot negate Unicode property of strings'); + } + return { + characters: (isUnicodeSetIgnoreCase ? UNICODE_IV_SET : UNICODE_SET).clone().remove(set.characters), + strings: new Set() + }; + } + return { + characters: set.characters.clone(), + strings: set.strings + // We need to escape strings like *️⃣ to make sure that they can be safely used in unions. + ? new Set(set.strings.map(str => str.replace(SYNTAX_CHARS, '\\$&'))) + : new Set() + }; +}; + +const getUnicodePropertyEscapeCharacterClassData = (property, isNegative, isUnicodeSetIgnoreCase, shouldApplySCF) => { + const set = getUnicodePropertyEscapeSet(property, isNegative, isUnicodeSetIgnoreCase); + const data = getCharacterClassEmptyData(); + const singleChars = shouldApplySCF ? regenerate(set.characters.toArray().map(ch => simpleCaseFolding(ch))) : set.characters; + const caseEqFlags = configGetCaseEqFlags(); + if (caseEqFlags) { + for (const codepoint of singleChars.toArray()) { + const list = getCaseEquivalents(codepoint, caseEqFlags); + if (list) { + singleChars.add(list); + } + } + } + data.singleChars = singleChars; + if (set.strings.size > 0) { + data.longStrings = set.strings; + data.maybeIncludesStrings = true; + } + return data; +}; + +const CASE_EQ_FLAG_NONE = 0b00; +const CASE_EQ_FLAG_BMP = 0b01; +const CASE_EQ_FLAG_UNICODE = 0b10; + +function configGetCaseEqFlags() { + let flags = CASE_EQ_FLAG_NONE; + if (config.modifiersData.i === true) { + if (config.transform.modifiers) { + flags |= CASE_EQ_FLAG_BMP; + if (config.flags.unicode || config.flags.unicodeSets) { + flags |= CASE_EQ_FLAG_UNICODE; + } + } + } else if (config.modifiersData.i === undefined) { + if (config.transform.unicodeFlag && config.flags.ignoreCase) { + flags |= CASE_EQ_FLAG_UNICODE; + } + } + return flags; +} + +// Given a range of code points, add any case-equivalent code points in that range +// to a set. +regenerate.prototype.iuAddRange = function(min, max, caseEqFlags) { + const $this = this; + do { + const list = getCaseEquivalents(min, caseEqFlags); + if (list) { + $this.add(list); + } + } while (++min <= max); + return $this; +}; +regenerate.prototype.iuRemoveRange = function(min, max, caseEqFlags) { + const $this = this; + do { + const list = getCaseEquivalents(min, caseEqFlags); + if (list) { + $this.remove(list); + } + } while (++min <= max); + return $this; +}; + +const update = (item, pattern) => { + let tree = parse(pattern, config.useUnicodeFlag ? 'u' : '', { + lookbehind: true, + namedGroups: true, + unicodePropertyEscape: true, + unicodeSet: true, + modifiers: true, + }); + switch (tree.type) { + case 'characterClass': + case 'group': + case 'value': + // No wrapping needed. + break; + default: + // Wrap the pattern in a non-capturing group. + tree = wrap(tree, pattern); + } + Object.assign(item, tree); +}; + +const wrap = (tree, pattern) => { + // Wrap the pattern in a non-capturing group. + return { + 'type': 'group', + 'behavior': 'ignore', + 'body': [tree], + 'raw': `(?:${ pattern })` + }; +}; + +/** + * Given any codepoint ch, returns false or an array of characters, + * such that for every c in the array, + * c != ch and Canonicalize(~, c) == Canonicalize(~, ch) + * + * where Canonicalize is defined in + * https://tc39.es/ecma262/#sec-runtime-semantics-canonicalize-ch + * @param {number} codePoint input code point + * @param {number} flags bitwise flags composed of CASE_EQ_FLAG_* + * @returns false | number[] + */ +const getCaseEquivalents = (codePoint, flags) => { + if (flags === CASE_EQ_FLAG_NONE) { + return false; + } + let result = ((flags & CASE_EQ_FLAG_UNICODE) ? iuMappings.get(codePoint) : undefined) || []; + if (typeof result === "number") result = [result]; + if (flags & CASE_EQ_FLAG_BMP) { + for (const cp of [codePoint].concat(result)) { + // Fast path for ASCII characters + if (cp >= 0x41 && cp <= 0x5a) { + result.push(cp + 0x20); + } else if (cp >= 0x61 && cp <= 0x7a) { + result.push(cp - 0x20); + } else { + result = result.concat(iBMPMappings.get(cp) || []); + } + } + } + return result.length == 0 ? false : result; +}; + +// https://tc39.es/ecma262/#sec-maybesimplecasefolding +const simpleCaseFolding = (codePoint) => { + // Fast path for ASCII characters + if (codePoint <= 0x7F) { + if (codePoint >= 0x41 && codePoint <= 0x5A) { + return codePoint + 0x20; + } + return codePoint; + } + return iuFoldings.get(codePoint) || codePoint; +} + +const buildHandler = (action) => { + switch (action) { + case 'union': + return { + single: (data, cp) => { + data.singleChars.add(cp); + }, + regSet: (data, set2) => { + data.singleChars.add(set2); + }, + range: (data, start, end) => { + data.singleChars.addRange(start, end); + }, + iuRange: (data, start, end, caseEqFlags) => { + data.singleChars.iuAddRange(start, end, caseEqFlags); + }, + nested: (data, nestedData) => { + data.singleChars.add(nestedData.singleChars); + for (const str of nestedData.longStrings) data.longStrings.add(str); + if (nestedData.maybeIncludesStrings) data.maybeIncludesStrings = true; + } + }; + case 'union-negative': { + const regSet = (data, set2) => { + data.singleChars = UNICODE_SET.clone().remove(set2).add(data.singleChars); + }; + return { + single: (data, cp) => { + const unicode = UNICODE_SET.clone(); + data.singleChars = data.singleChars.contains(cp) ? unicode : unicode.remove(cp); + }, + regSet: regSet, + range: (data, start, end) => { + data.singleChars = UNICODE_SET.clone().removeRange(start, end).add(data.singleChars); + }, + iuRange: (data, start, end, caseEqFlags) => { + data.singleChars = UNICODE_SET.clone().iuRemoveRange(start, end, caseEqFlags).add(data.singleChars); + }, + nested: (data, nestedData) => { + regSet(data, nestedData.singleChars); + if (nestedData.maybeIncludesStrings) throw new Error('ASSERTION ERROR'); + } + }; + } + case 'intersection': { + const regSet = (data, set2) => { + if (data.first) data.singleChars = set2; + else data.singleChars.intersection(set2); + }; + return { + single: (data, cp) => { + data.singleChars = data.first || data.singleChars.contains(cp) ? regenerate(cp) : regenerate(); + data.longStrings.clear(); + data.maybeIncludesStrings = false; + }, + regSet: (data, set) => { + regSet(data, set); + data.longStrings.clear(); + data.maybeIncludesStrings = false; + }, + range: (data, start, end) => { + if (data.first) data.singleChars.addRange(start, end); + else data.singleChars.intersection(regenerate().addRange(start, end)); + data.longStrings.clear(); + data.maybeIncludesStrings = false; + }, + iuRange: (data, start, end, caseEqFlags) => { + if (data.first) data.singleChars.iuAddRange(start, end, caseEqFlags); + else data.singleChars.intersection(regenerate().iuAddRange(start, end, caseEqFlags)); + data.longStrings.clear(); + data.maybeIncludesStrings = false; + }, + nested: (data, nestedData) => { + regSet(data, nestedData.singleChars); + + if (data.first) { + data.longStrings = nestedData.longStrings; + data.maybeIncludesStrings = nestedData.maybeIncludesStrings; + } else { + for (const str of data.longStrings) { + if (!nestedData.longStrings.has(str)) data.longStrings.delete(str); + } + if (!nestedData.maybeIncludesStrings) data.maybeIncludesStrings = false; + } + } + }; + } + case 'subtraction': { + const regSet = (data, set2) => { + if (data.first) data.singleChars.add(set2); + else data.singleChars.remove(set2); + }; + return { + single: (data, cp) => { + if (data.first) data.singleChars.add(cp); + else data.singleChars.remove(cp); + }, + regSet: regSet, + range: (data, start, end) => { + if (data.first) data.singleChars.addRange(start, end); + else data.singleChars.removeRange(start, end); + }, + iuRange: (data, start, end, caseEqFlags) => { + if (data.first) data.singleChars.iuAddRange(start, end, caseEqFlags); + else data.singleChars.iuRemoveRange(start, end, caseEqFlags); + }, + nested: (data, nestedData) => { + regSet(data, nestedData.singleChars); + + if (data.first) { + data.longStrings = nestedData.longStrings; + data.maybeIncludesStrings = nestedData.maybeIncludesStrings; + } else { + for (const str of data.longStrings) { + if (nestedData.longStrings.has(str)) data.longStrings.delete(str); + } + } + } + }; + } + // The `default` clause is only here as a safeguard; it should never be + // reached. Code coverage tools should ignore it. + /* node:coverage ignore next */ + default: + throw new Error(`Unknown set action: ${ characterClassItem.kind }`); + } +}; + +const getCharacterClassEmptyData = () => ({ + transformed: config.transform.unicodeFlag, + singleChars: regenerate(), + longStrings: new Set(), + hasEmptyString: false, + first: true, + maybeIncludesStrings: false +}); + +const concatCaseEquivalents = (codePoint, caseEqFlags) => { + const caseEquivalents = getCaseEquivalents(codePoint, caseEqFlags); + if (caseEquivalents) { + return [codePoint, ...caseEquivalents]; + } + return [codePoint]; +}; + +const computeClassStrings = (classStrings, regenerateOptions, caseEqFlags, shouldApplySCF) => { + let data = getCharacterClassEmptyData(); + + for (const string of classStrings.strings) { + if (string.characters.length === 1) { + const codePoint = shouldApplySCF ? simpleCaseFolding(string.characters[0].codePoint) : string.characters[0].codePoint + concatCaseEquivalents(codePoint, caseEqFlags).forEach((cp) => { + data.singleChars.add(cp); + }); + } else { + let stringifiedString = ''; + if (caseEqFlags) { + for (const ch of string.characters) { + const codePoint = shouldApplySCF ? simpleCaseFolding(ch.codePoint) : ch.codePoint; + const set = regenerate(concatCaseEquivalents(codePoint, caseEqFlags)); + stringifiedString += set.toString(regenerateOptions); + } + } else { + for (const ch of string.characters) { + const codePoint = shouldApplySCF ? simpleCaseFolding(ch.codePoint) : ch.codePoint; + if (codePoint !== ch.codePoint) { + stringifiedString += regenerate(codePoint).toString(regenerateOptions); + } else { + stringifiedString += generate(ch); + } + } + } + + data.longStrings.add(stringifiedString); + data.maybeIncludesStrings = true; + } + } + + return data; +} + +const computeCharacterClass = (characterClassItem, regenerateOptions, shouldApplySCF) => { + let data = getCharacterClassEmptyData(); + + let handlePositive; + let handleNegative; + + let caseEqFlags = configGetCaseEqFlags(); + + switch (characterClassItem.kind) { + case 'union': + handlePositive = buildHandler('union'); + handleNegative = buildHandler('union-negative'); + break; + case 'intersection': + handlePositive = buildHandler('intersection'); + handleNegative = buildHandler('subtraction'); + if (config.transform.unicodeSetsFlag) data.transformed = true; + if (config.isIgnoreCaseMode) { + shouldApplySCF = true; + } + break; + case 'subtraction': + handlePositive = buildHandler('subtraction'); + handleNegative = buildHandler('intersection'); + if (config.transform.unicodeSetsFlag) data.transformed = true; + if (config.isIgnoreCaseMode) { + shouldApplySCF = true; + } + break; + // The `default` clause is only here as a safeguard; it should never be + // reached. Code coverage tools should ignore it. + /* node:coverage ignore next */ + default: + throw new Error(`Unknown character class kind: ${ characterClassItem.kind }`); + } + + for (const item of characterClassItem.body) { + switch (item.type) { + case 'value': + const codePoint = shouldApplySCF ? simpleCaseFolding(item.codePoint) : item.codePoint; + const list = concatCaseEquivalents(codePoint, caseEqFlags); + handlePositive.regSet(data, regenerate(list)); + if (list.length > 1) { + data.transformed = true; + } + break; + case 'characterClassRange': + const min = item.min.codePoint; + const max = item.max.codePoint; + if (shouldApplySCF) { + let list = []; + for (let cp = min; cp <= max; cp++) { + list.push(simpleCaseFolding(cp)); + } + handlePositive.regSet(data, regenerate(list)); + } else { + handlePositive.range(data, min, max); + } + if (caseEqFlags) { + // If shouldApplySCF is true, it is still ok to call iuRange because + // the set [min, max] shares the same case equivalents with scf([min, max]) + handlePositive.iuRange(data, min, max, caseEqFlags); + data.transformed = true; + } + break; + case 'characterClassEscape': + handlePositive.regSet(data, getCharacterClassEscapeSet( + item.value, + config.flags.unicode || config.flags.unicodeSets, + config.flags.ignoreCase, + shouldApplySCF + )); + break; + case 'unicodePropertyEscape': + const nestedData = getUnicodePropertyEscapeCharacterClassData( + item.value, + item.negative, + config.flags.unicodeSets && config.isIgnoreCaseMode, + shouldApplySCF + ); + handlePositive.nested(data, nestedData); + data.transformed = + data.transformed || + config.transform.unicodePropertyEscapes || + (config.transform.unicodeSetsFlag && (nestedData.maybeIncludesStrings || characterClassItem.kind !== "union" || item.negative)); + break; + case 'characterClass': + const handler = item.negative ? handleNegative : handlePositive; + const res = computeCharacterClass(item, regenerateOptions, shouldApplySCF); + handler.nested(data, res); + data.transformed = true; + break; + case 'classStrings': + handlePositive.nested(data, computeClassStrings(item, regenerateOptions, caseEqFlags, shouldApplySCF)); + data.transformed = true; + break; + // The `default` clause is only here as a safeguard; it should never be + // reached. Code coverage tools should ignore it. + /* node:coverage ignore next */ + default: + throw new Error(`Unknown term type: ${ item.type }`); + } + + data.first = false; + } + + if (characterClassItem.negative && data.maybeIncludesStrings) { + throw new SyntaxError('Cannot negate set containing strings'); + } + + return data; +} + +const processCharacterClass = ( + characterClassItem, + regenerateOptions, + computed = computeCharacterClass(characterClassItem, regenerateOptions) +) => { + const negative = characterClassItem.negative; + const { singleChars, transformed, longStrings } = computed; + if (transformed) { + // If single chars already contains some astral character, regenerate (bmpOnly: true) will create valid regex strings + const bmpOnly = regenerateContainsAstral(singleChars); + const setStr = singleChars.toString(Object.assign({}, regenerateOptions, { bmpOnly: bmpOnly })); + + if (negative) { + if (config.useUnicodeFlag) { + update(characterClassItem, `[^${setStr[0] === '[' ? setStr.slice(1, -1) : setStr}]`) + } else { + if (config.flags.unicode || config.flags.unicodeSets) { + if (config.flags.ignoreCase) { + const astralCharsSet = singleChars.clone().intersection(ASTRAL_SET); + // Assumption: singleChars do not contain lone surrogates. + // Regex like /[^\ud800]/u is not supported + const surrogateOrBMPSetStr = singleChars + .clone() + .remove(astralCharsSet) + .addRange(0xd800, 0xdfff) + .toString({ bmpOnly: true }); + // Don't generate negative lookahead for astral characters + // because the case folding is not working anyway as we break + // code points into surrogate pairs. + const astralNegativeSetStr = ASTRAL_SET + .clone() + .remove(astralCharsSet) + .toString(regenerateOptions); + // The transform here does not support lone surrogates. + update( + characterClassItem, + `(?!${surrogateOrBMPSetStr})[^]|${astralNegativeSetStr}` + ); + } else { + // Generate negative set directly when case folding is not involved. + const negativeSet = UNICODE_SET.clone().remove(singleChars); + update(characterClassItem, negativeSet.toString(regenerateOptions)); + } + } else { + update(characterClassItem, `(?!${setStr})[^]`); + } + } + } else { + const hasEmptyString = longStrings.has(''); + const pieces = Array.from(longStrings).sort((a, b) => b.length - a.length); + + if (setStr !== '[]' || longStrings.size === 0) { + pieces.splice(pieces.length - (hasEmptyString ? 1 : 0), 0, setStr); + } + + update(characterClassItem, pieces.join('|')); + } + } + return characterClassItem; +}; + +const assertNoUnmatchedReferences = (groups) => { + const unmatchedReferencesNames = Object.keys(groups.unmatchedReferences); + if (unmatchedReferencesNames.length > 0) { + throw new Error(`Unknown group names: ${unmatchedReferencesNames}`); + } +}; + +const processModifiers = (item, regenerateOptions, groups) => { + const enabling = item.modifierFlags.enabling; + const disabling = item.modifierFlags.disabling; + + const oldData = Object.assign({}, config.modifiersData); + + for (const flag of enabling) { + config.modifiersData[flag] = true; + } + for (const flag of disabling) { + config.modifiersData[flag] = false; + } + + if (config.transform.modifiers) { + delete item.modifierFlags; + item.behavior = 'ignore'; + } + + item.body = item.body.map(term => { + return processTerm(term, regenerateOptions, groups); + }); + + config.modifiersData = oldData; + + return item; +} + +const processTerm = (item, regenerateOptions, groups) => { + switch (item.type) { + case 'dot': + if (config.transform.unicodeFlag) { + update( + item, + getUnicodeDotSet(config.isDotAllMode).toString(regenerateOptions) + ); + } else if ((config.modifiersData.s != null ? config.modifiersData.s && config.transform.modifiers : config.transform.dotAllFlag)) { + // TODO: consider changing this at the regenerate level. + update(item, '[^]'); + } + break; + case 'characterClass': + item = processCharacterClass(item, regenerateOptions); + break; + case 'unicodePropertyEscape': + const data = getUnicodePropertyEscapeCharacterClassData(item.value, item.negative, config.flags.unicodeSets && config.isIgnoreCaseMode); + if (data.maybeIncludesStrings) { + if (!config.flags.unicodeSets) { + throw new Error( + 'Properties of strings are only supported when using the unicodeSets (v) flag.' + ); + } + if (config.transform.unicodeSetsFlag) { + data.transformed = true; + item = processCharacterClass(item, regenerateOptions, data); + } + } else if (config.transform.unicodePropertyEscapes || configGetCaseEqFlags()) { + update( + item, + data.singleChars.toString(regenerateOptions) + ); + } + break; + case 'characterClassEscape': + if (config.transform.unicodeFlag) { + update( + item, + getCharacterClassEscapeSet( + item.value, + /* config.transform.unicodeFlag implies config.flags.unicode */ true, + config.flags.ignoreCase + ).toString(regenerateOptions) + ); + } + break; + case 'group': + if (item.behavior == 'normal') { + groups.lastIndex++; + } + if (item.name) { + const name = item.name.value; + + if (groups.namesConflicts[name]) { + throw new Error( + `Group '${ name }' has already been defined in this context.` + ); + } + groups.namesConflicts[name] = true; + + if (config.transform.namedGroups) { + delete item.name; + } + + const index = groups.lastIndex; + if (!groups.names[name]) { + groups.names[name] = []; + } + groups.names[name].push(index); + + if (groups.onNamedGroup) { + groups.onNamedGroup.call(null, name, index); + } + + if (groups.unmatchedReferences[name]) { + delete groups.unmatchedReferences[name]; + } + } + if (item.modifierFlags) { + return processModifiers(item, regenerateOptions, groups); + } + /* falls through */ + case 'quantifier': + item.body = item.body.map(term => { + return processTerm(term, regenerateOptions, groups); + }); + break; + case 'disjunction': + const outerNamesConflicts = groups.namesConflicts; + item.body = item.body.map(term => { + groups.namesConflicts = Object.create(outerNamesConflicts); + return processTerm(term, regenerateOptions, groups); + }); + break; + case 'alternative': + item.body = flatMap(item.body, term => { + const res = processTerm(term, regenerateOptions, groups); + // Alternatives cannot contain alternatives; flatten them. + return res.type === 'alternative' ? res.body : res; + }); + break; + case 'value': + const codePoint = item.codePoint; + const caseEqFlags = configGetCaseEqFlags(); + const list = concatCaseEquivalents(codePoint, caseEqFlags); + if (list.length === 1 && item.kind === "symbol" && codePoint >= 0x20 && codePoint <= 0x7E) { + // skip regenerate when it is a printable ASCII symbol + break; + } + const set = regenerate(list); + update(item, set.toString(regenerateOptions)); + break; + case 'reference': + if (item.name) { + const name = item.name.value; + const indexes = groups.names[name]; + if (!indexes) { + groups.unmatchedReferences[name] = true; + } + + if (config.transform.namedGroups) { + if (indexes) { + const body = indexes.map(index => ({ + 'type': 'reference', + 'matchIndex': index, + 'raw': '\\' + index, + })); + if (body.length === 1) { + return body[0]; + } + return { + 'type': 'alternative', + 'body': body, + 'raw': body.map(term => term.raw).join(''), + }; + } + + // This named reference comes before the group where it’s defined, + // so it’s always an empty match. + return { + 'type': 'group', + 'behavior': 'ignore', + 'body': [], + 'raw': '(?:)', + }; + } + } + break; + case 'anchor': + if (config.modifiersData.m && config.transform.modifiers) { + if (item.kind == 'start') { + update(item, `(?:^|(?<=${NEWLINE_SET.toString()}))`); + } else if (item.kind == 'end') { + update(item, `(?:$|(?=${NEWLINE_SET.toString()}))`); + } + } + case 'empty': + // Nothing to do here. + break; + // The `default` clause is only here as a safeguard; it should never be + // reached. Code coverage tools should ignore it. + /* node:coverage ignore next */ + default: + throw new Error(`Unknown term type: ${ item.type }`); + } + return item; +}; + +const config = { + 'flags': { + 'ignoreCase': false, + 'unicode': false, + 'unicodeSets': false, + 'dotAll': false, + 'multiline': false, + }, + 'transform': { + 'dotAllFlag': false, + 'unicodeFlag': false, + 'unicodeSetsFlag': false, + 'unicodePropertyEscapes': false, + 'namedGroups': false, + 'modifiers': false, + }, + 'modifiersData': { + 'i': undefined, + 's': undefined, + 'm': undefined, + }, + get useUnicodeFlag() { + return (this.flags.unicode || this.flags.unicodeSets) && !this.transform.unicodeFlag; + }, + get isDotAllMode() { + return (this.modifiersData.s !== undefined ? this.modifiersData.s : this.flags.dotAll); + }, + get isIgnoreCaseMode() { + return (this.modifiersData.i !== undefined ? this.modifiersData.i : this.flags.ignoreCase); + } +}; + +const validateOptions = (options) => { + if (!options) return; + + for (const key of Object.keys(options)) { + const value = options[key]; + switch (key) { + case 'dotAllFlag': + case 'unicodeFlag': + case 'unicodePropertyEscapes': + case 'unicodeSetsFlag': + case 'namedGroups': + if (value != null && value !== false && value !== 'transform') { + throw new Error(`.${key} must be false (default) or 'transform'.`); + } + break; + // todo: remove modifiers: 'parse' in regexpu-core v7 + case 'modifiers': + if (value != null && value !== false && value !== 'parse' && value !== 'transform') { + throw new Error(`.${key} must be false (default), 'parse' or 'transform'.`); + } + break; + case 'onNamedGroup': + case 'onNewFlags': + if (value != null && typeof value !== 'function') { + throw new Error(`.${key} must be a function.`); + } + break; + default: + throw new Error(`.${key} is not a valid regexpu-core option.`); + } + } +}; + +const hasFlag = (flags, flag) => flags ? flags.includes(flag) : false; +const transform = (options, name) => options ? options[name] === 'transform' : false; + +const rewritePattern = (pattern, flags, options) => { + validateOptions(options); + + config.flags.unicode = hasFlag(flags, 'u'); + config.flags.unicodeSets = hasFlag(flags, 'v'); + config.flags.ignoreCase = hasFlag(flags, 'i'); + config.flags.dotAll = hasFlag(flags, 's'); + config.flags.multiline = hasFlag(flags, 'm'); + + config.transform.dotAllFlag = config.flags.dotAll && transform(options, 'dotAllFlag'); + config.transform.unicodeFlag = (config.flags.unicode || config.flags.unicodeSets) && transform(options, 'unicodeFlag'); + config.transform.unicodeSetsFlag = config.flags.unicodeSets && transform(options, 'unicodeSetsFlag'); + + // unicodeFlag: 'transform' implies unicodePropertyEscapes: 'transform' + config.transform.unicodePropertyEscapes = (config.flags.unicode || config.flags.unicodeSets) && ( + transform(options, 'unicodeFlag') || transform(options, 'unicodePropertyEscapes') + ); + config.transform.namedGroups = transform(options, 'namedGroups'); + config.transform.modifiers = transform(options, 'modifiers'); + + config.modifiersData.i = undefined; + config.modifiersData.s = undefined; + config.modifiersData.m = undefined; + + const regjsparserFeatures = { + // Enable every stable RegExp feature by default + 'modifiers': true, + 'unicodePropertyEscape': true, + 'unicodeSet': true, + 'namedGroups': true, + 'lookbehind': true, + }; + + const regenerateOptions = { + 'hasUnicodeFlag': config.useUnicodeFlag, + 'bmpOnly': !config.flags.unicode && !config.flags.unicodeSets + }; + + const groups = { + 'onNamedGroup': options && options.onNamedGroup, + 'lastIndex': 0, + 'names': Object.create(null), // { [name]: Array } + 'namesConflicts': Object.create(null), // { [name]: true } + 'unmatchedReferences': Object.create(null) // { [name]: true } + }; + + const tree = parse(pattern, flags, regjsparserFeatures); + + if (config.transform.modifiers) { + if (/\(\?[a-z]*-[a-z]+:/.test(pattern)) { + // the pattern _likely_ contain inline disabled modifiers + // we need to traverse to make sure that they are actually modifiers and to collect them + const allDisabledModifiers = Object.create(null) + const itemStack = [tree]; + let node; + while (node = itemStack.pop(), node != undefined) { + if (Array.isArray(node)) { + Array.prototype.push.apply(itemStack, node); + } else if (typeof node == 'object' && node != null) { + for (const key of Object.keys(node)) { + const value = node[key]; + if (key == 'modifierFlags') { + for (const flag of value.disabling) { + allDisabledModifiers[flag] = true; + } + } else if (typeof value == 'object' && value != null) { + itemStack.push(value); + } + } + } + } + if (allDisabledModifiers.i) { + config.modifiersData.i = config.flags.ignoreCase; + } + if (allDisabledModifiers.m) { + config.modifiersData.m = config.flags.multiline; + } + if (allDisabledModifiers.s) { + config.modifiersData.s = config.flags.dotAll; + } + } + } + + // Note: `processTerm` mutates `tree` and `groups`. + processTerm(tree, regenerateOptions, groups); + assertNoUnmatchedReferences(groups); + + const onNewFlags = options && options.onNewFlags; + if (onNewFlags) { + let newFlags = flags.split('').filter((flag) => !config.modifiersData[flag]).join(''); + if (config.transform.unicodeSetsFlag) { + newFlags = newFlags.replace('v', 'u'); + } + if (config.transform.unicodeFlag) { + newFlags = newFlags.replace('u', ''); + } + if (config.transform.dotAllFlag) { + newFlags = newFlags.replace('s', ''); + } + onNewFlags(newFlags); + } + + return generate(tree); +}; + +module.exports = rewritePattern; diff --git a/tools/ui/node_modules/regjsgen/LICENSE-MIT.txt b/tools/ui/node_modules/regjsgen/LICENSE-MIT.txt new file mode 100644 index 0000000000000000000000000000000000000000..591526bd726888226028851c6cc15e98c7c4dd5c --- /dev/null +++ b/tools/ui/node_modules/regjsgen/LICENSE-MIT.txt @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright 2014-2020 Benjamin Tan + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/regjsgen/README.md b/tools/ui/node_modules/regjsgen/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9c12421171065b661c19257a39c74bd5b2bf8efa --- /dev/null +++ b/tools/ui/node_modules/regjsgen/README.md @@ -0,0 +1,41 @@ +# regjsgen [![Build status][ci-img]][ci] [![Code coverage status][codecov-img]][codecov] + +Generate regular expressions from [regjsparser][regjsparser]’s AST. + +## Installation + +```sh +npm i regjsgen +``` + +## API + +### `regjsgen.generate(ast)` + +This function accepts an abstract syntax tree representing a regular expression (see [regjsparser][regjsparser]), and returns the generated regular expression string. + +```js +const regjsparser = require('regjsparser'); +const regjsgen = require('regjsgen'); + +// Generate an AST with `regjsparser`. +let ast = regjsparser.parse(regex); + +// Modify AST +// … + +// Generate `RegExp` string with `regjsgen`. +let regex = regjsgen.generate(ast); +``` + +## Support + +Tested on Node.js 16 and 18.
+Compatible with regjsparser v0.10.0’s AST. + + +[ci]: https://github.com/bnjmnt4n/regjsgen/actions +[ci-img]: https://github.com/bnjmnt4n/regjsgen/workflows/Node.js%20CI/badge.svg +[codecov]: https://codecov.io/gh/bnjmnt4n/regjsgen +[codecov-img]: https://codecov.io/gh/bnjmnt4n/regjsgen/branch/main/graph/badge.svg +[regjsparser]: https://github.com/jviereck/regjsparser diff --git a/tools/ui/node_modules/regjsgen/package.json b/tools/ui/node_modules/regjsgen/package.json new file mode 100644 index 0000000000000000000000000000000000000000..589a15f6c03fdd85217383b065ab38672a0fc469 --- /dev/null +++ b/tools/ui/node_modules/regjsgen/package.json @@ -0,0 +1,40 @@ +{ + "name": "regjsgen", + "version": "0.8.0", + "description": "Generate regular expressions from regjsparser’s AST.", + "homepage": "https://github.com/bnjmnt4n/regjsgen", + "main": "regjsgen.js", + "keywords": [ + "ast", + "generate", + "regex", + "regexp", + "regular expressions" + ], + "license": "MIT", + "author": { + "name": "Benjamin Tan", + "url": "https://ofcr.se/" + }, + "repository": { + "type": "git", + "url": "https://github.com/bnjmnt4n/regjsgen.git" + }, + "bugs": "https://github.com/bnjmnt4n/regjsgen/issues", + "files": [ + "LICENSE-MIT.txt", + "regjsgen.js" + ], + "scripts": { + "test": "node tests/tests.js", + "coverage": "nyc --reporter=html npm test", + "report-coverage": "nyc --reporter=lcov npm test && codecov", + "update-fixtures": "node tests/update-fixtures.js" + }, + "devDependencies": { + "codecov": "^3.8.3", + "nyc": "^15.1.0", + "regjsparser": "^0.10.0", + "request": "^2.88.2" + } +} diff --git a/tools/ui/node_modules/regjsgen/regjsgen.js b/tools/ui/node_modules/regjsgen/regjsgen.js new file mode 100644 index 0000000000000000000000000000000000000000..baf7aa1c63c80523c6b9b501a3ea1d3f957a0c37 --- /dev/null +++ b/tools/ui/node_modules/regjsgen/regjsgen.js @@ -0,0 +1,425 @@ +/*! + * regjsgen 0.8.0 + * Copyright 2014-2023 Benjamin Tan + * Available under the MIT license + */ +;(function() { + 'use strict'; + + // Used to determine if values are of the language type `Object`. + var objectTypes = { + 'function': true, + 'object': true + }; + + // Used as a reference to the global object. + var root = (objectTypes[typeof window] && window) || this; + + // Detect free variable `exports`. + var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports; + + // Detect free variable `module`. + var hasFreeModule = objectTypes[typeof module] && module && !module.nodeType; + + // Detect free variable `global` from Node.js or Browserified code and use it as `root`. + var freeGlobal = freeExports && hasFreeModule && typeof global == 'object' && global; + if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) { + root = freeGlobal; + } + + // Used to check objects for own properties. + var hasOwnProperty = Object.prototype.hasOwnProperty; + + /*--------------------------------------------------------------------------*/ + + // Generates a string based on the given code point. + // Based on https://mths.be/fromcodepoint by @mathias. + function fromCodePoint() { + var codePoint = Number(arguments[0]); + + if ( + !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity` + codePoint < 0 || // not a valid Unicode code point + codePoint > 0x10FFFF || // not a valid Unicode code point + Math.floor(codePoint) != codePoint // not an integer + ) { + throw RangeError('Invalid code point: ' + codePoint); + } + + if (codePoint <= 0xFFFF) { + // BMP code point + return String.fromCharCode(codePoint); + } else { + // Astral code point; split in surrogate halves + // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + codePoint -= 0x10000; + var highSurrogate = (codePoint >> 10) + 0xD800; + var lowSurrogate = (codePoint % 0x400) + 0xDC00; + return String.fromCharCode(highSurrogate, lowSurrogate); + } + } + + /*--------------------------------------------------------------------------*/ + + // Ensures that nodes have the correct types. + var assertTypeRegexMap = {}; + function assertType(type, expected) { + if (expected.indexOf('|') == -1) { + if (type == expected) { + return; + } + + throw Error('Invalid node type: ' + type + '; expected type: ' + expected); + } + + expected = hasOwnProperty.call(assertTypeRegexMap, expected) + ? assertTypeRegexMap[expected] + : (assertTypeRegexMap[expected] = RegExp('^(?:' + expected + ')$')); + + if (expected.test(type)) { + return; + } + + throw Error('Invalid node type: ' + type + '; expected types: ' + expected); + } + + /*--------------------------------------------------------------------------*/ + + // Generates a regular expression string based on an AST. + function generate(node) { + var type = node.type; + + if (hasOwnProperty.call(generators, type)) { + return generators[type](node); + } + + throw Error('Invalid node type: ' + type); + } + + // Constructs a string by concatentating the output of each term. + function generateSequence(generator, terms, /* optional */ separator) { + var i = -1, + length = terms.length, + result = '', + term; + + while (++i < length) { + term = terms[i]; + + if (separator && i > 0) result += separator; + + // Ensure that `\0` null escapes followed by number symbols are not + // treated as backreferences. + if ( + i + 1 < length && + terms[i].type == 'value' && + terms[i].kind == 'null' && + terms[i + 1].type == 'value' && + terms[i + 1].kind == 'symbol' && + terms[i + 1].codePoint >= 48 && + terms[i + 1].codePoint <= 57 + ) { + result += '\\000'; + continue; + } + + result += generator(term); + } + + return result; + } + + /*--------------------------------------------------------------------------*/ + + function generateAlternative(node) { + assertType(node.type, 'alternative'); + + return generateSequence(generateTerm, node.body); + } + + function generateAnchor(node) { + assertType(node.type, 'anchor'); + + switch (node.kind) { + case 'start': + return '^'; + case 'end': + return '$'; + case 'boundary': + return '\\b'; + case 'not-boundary': + return '\\B'; + default: + throw Error('Invalid assertion'); + } + } + + var atomType = 'anchor|characterClass|characterClassEscape|dot|group|reference|unicodePropertyEscape|value'; + + function generateAtom(node) { + assertType(node.type, atomType); + + return generate(node); + } + + function generateCharacterClass(node) { + assertType(node.type, 'characterClass'); + + var kind = node.kind; + var separator = kind === 'intersection' ? '&&' : kind === 'subtraction' ? '--' : ''; + + return '[' + + (node.negative ? '^' : '') + + generateSequence(generateClassAtom, node.body, separator) + + ']'; + } + + function generateCharacterClassEscape(node) { + assertType(node.type, 'characterClassEscape'); + + return '\\' + node.value; + } + + function generateCharacterClassRange(node) { + assertType(node.type, 'characterClassRange'); + + var min = node.min, + max = node.max; + + if (min.type == 'characterClassRange' || max.type == 'characterClassRange') { + throw Error('Invalid character class range'); + } + + return generateClassAtom(min) + '-' + generateClassAtom(max); + } + + function generateClassAtom(node) { + assertType(node.type, 'anchor|characterClass|characterClassEscape|characterClassRange|dot|value|unicodePropertyEscape|classStrings'); + + return generate(node); + } + + function generateClassStrings(node) { + assertType(node.type, 'classStrings'); + + return '\\q{' + generateSequence(generateClassString, node.strings, '|') + '}'; + } + + function generateClassString(node) { + assertType(node.type, 'classString'); + + return generateSequence(generate, node.characters); + } + + function generateDisjunction(node) { + assertType(node.type, 'disjunction'); + + return generateSequence(generate, node.body, '|'); + } + + + function generateDot(node) { + assertType(node.type, 'dot'); + + return '.'; + } + + function generateGroup(node) { + assertType(node.type, 'group'); + + var result = ''; + + switch (node.behavior) { + case 'normal': + if (node.name) { + result += '?<' + generateIdentifier(node.name) + '>'; + } + break; + case 'ignore': + if (node.modifierFlags) { + result += '?'; + if (node.modifierFlags.enabling) result += node.modifierFlags.enabling; + if (node.modifierFlags.disabling) result += "-" + node.modifierFlags.disabling; + result += ':'; + } else { + result += '?:'; + } + break; + case 'lookahead': + result += '?='; + break; + case 'negativeLookahead': + result += '?!'; + break; + case 'lookbehind': + result += '?<='; + break; + case 'negativeLookbehind': + result += '?'; + } + + throw new Error('Unknown reference type'); + } + + function generateTerm(node) { + assertType(node.type, atomType + '|empty|quantifier'); + + return generate(node); + } + + function generateUnicodePropertyEscape(node) { + assertType(node.type, 'unicodePropertyEscape'); + + return '\\' + (node.negative ? 'P' : 'p') + '{' + node.value + '}'; + } + + function generateValue(node) { + assertType(node.type, 'value'); + + var kind = node.kind, + codePoint = node.codePoint; + + if (typeof codePoint != 'number') { + throw new Error('Invalid code point: ' + codePoint); + } + + switch (kind) { + case 'controlLetter': + return '\\c' + fromCodePoint(codePoint + 64); + case 'hexadecimalEscape': + return '\\x' + ('00' + codePoint.toString(16).toUpperCase()).slice(-2); + case 'identifier': + return '\\' + fromCodePoint(codePoint); + case 'null': + return '\\' + codePoint; + case 'octal': + return '\\' + ('000' + codePoint.toString(8)).slice(-3); + case 'singleEscape': + switch (codePoint) { + case 0x0008: + return '\\b'; + case 0x0009: + return '\\t'; + case 0x000A: + return '\\n'; + case 0x000B: + return '\\v'; + case 0x000C: + return '\\f'; + case 0x000D: + return '\\r'; + case 0x002D: + return '\\-'; + default: + throw Error('Invalid code point: ' + codePoint); + } + case 'symbol': + return fromCodePoint(codePoint); + case 'unicodeEscape': + return '\\u' + ('0000' + codePoint.toString(16).toUpperCase()).slice(-4); + case 'unicodeCodePointEscape': + return '\\u{' + codePoint.toString(16).toUpperCase() + '}'; + default: + throw Error('Unsupported node kind: ' + kind); + } + } + + /*--------------------------------------------------------------------------*/ + + // Used to generate strings for each node type. + var generators = { + 'alternative': generateAlternative, + 'anchor': generateAnchor, + 'characterClass': generateCharacterClass, + 'characterClassEscape': generateCharacterClassEscape, + 'characterClassRange': generateCharacterClassRange, + 'classStrings': generateClassStrings, + 'disjunction': generateDisjunction, + 'dot': generateDot, + 'group': generateGroup, + 'quantifier': generateQuantifier, + 'reference': generateReference, + 'unicodePropertyEscape': generateUnicodePropertyEscape, + 'value': generateValue + }; + + /*--------------------------------------------------------------------------*/ + + // Export regjsgen. + var regjsgen = { + 'generate': generate + }; + + // Some AMD build optimizers, like r.js, check for condition patterns like the following: + if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) { + // Define as an anonymous module so it can be aliased through path mapping. + define(function() { + return regjsgen; + }); + + root.regjsgen = regjsgen; + } + // Check for `exports` after `define` in case a build optimizer adds an `exports` object. + else if (freeExports && hasFreeModule) { + // Export for CommonJS support. + freeExports.generate = generate; + } + else { + // Export to the global object. + root.regjsgen = regjsgen; + } +}.call(this)); diff --git a/tools/ui/node_modules/regjsparser/LICENSE.BSD b/tools/ui/node_modules/regjsparser/LICENSE.BSD new file mode 100644 index 0000000000000000000000000000000000000000..9aaf45cf3eb4e467fd384f4ad9c805eefee66d0a --- /dev/null +++ b/tools/ui/node_modules/regjsparser/LICENSE.BSD @@ -0,0 +1,21 @@ +Copyright (c) Julian Viereck and Contributors, All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/tools/ui/node_modules/regjsparser/README.md b/tools/ui/node_modules/regjsparser/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2b2818ce0bceb38fcf1772b28044d3ce7229bef7 --- /dev/null +++ b/tools/ui/node_modules/regjsparser/README.md @@ -0,0 +1,47 @@ +# RegJSParser + +Parsing the JavaScript's RegExp in JavaScript. + +## Installation + +```bash +npm install regjsparser +``` + +## Usage + +```js +var parse = require('regjsparser').parse; + +var parseTree = parse('^a'); // /^a/ +console.log(parseTree); + +// Toggle on/off additional features: +var parseTree = parse('^a', '', { + // SEE: https://github.com/jviereck/regjsparser/pull/78 + unicodePropertyEscape: true, + + // SEE: https://github.com/jviereck/regjsparser/pull/83 + namedGroups: true, + + // SEE: https://github.com/jviereck/regjsparser/pull/89 + lookbehind: true +}); +console.log(parseTree); +``` + +## Testing + +To run the tests, run the following command: + +```bash +npm test +``` + +To create a new reference file, execute… + +```bash +node test/update-fixtures.js +``` + +…from the repo top directory. diff --git a/tools/ui/node_modules/regjsparser/bin/parser b/tools/ui/node_modules/regjsparser/bin/parser new file mode 100644 index 0000000000000000000000000000000000000000..73549ac07214ef6b39bfdf8f8811a6c2e02ebbb4 --- /dev/null +++ b/tools/ui/node_modules/regjsparser/bin/parser @@ -0,0 +1,63 @@ +#!/usr/bin/env node +(function() { + + var fs = require('fs'); + var path = require('path'); + var parse = require('../parser').parse; + var jsesc = require('jsesc'); + var regexes = process.argv.splice(2); + var first = regexes[0]; + var data; + var log = console.log; + var flags = ''; + var main = function() { + if (/^(?:-h|--help|undefined)$/.test(first)) { + log([ + '\nUsage:\n', + '\tregjsparser [regex ...]', + '\tregjsparser [-f | --flags] u [regex ...]', + '\tregjsparser [-v | --version]', + '\tregjsparser [-h | --help]', + '\nExamples:\n', + '\tregjsparser \'^foo.bar$\'', + '\tregjsparser \'[a-zA-Z0-9]\'' + ].join('\n')); + return process.exit(1); + } + + if (/^(?:-v|--version)$/.test(first)) { + log('v%s', require(path.resolve(__dirname, '../package.json')).version); + return process.exit(1); + } + + if (/^(?:-f|--flags)$/.test(first)) { + flags = regexes[1]; + regexes = regexes.slice(2); + } + + regexes.forEach(function(snippet) { + try { + result = parse(snippet, flags); + log(jsesc(result, { + 'json': true, + 'compact': false, + 'indent': '\t' + })); + } catch(error) { + log(error.message + '\n'); + log('Error: failed to parse. Make sure the regular expression is valid.'); + log('If you think this is a bug in regjsparser, please report it:'); + log('\thttps://github.com/jviereck/regjsparser/issues/new'); + log('\nStack trace:\n'); + log(error.stack); + return process.exit(1); + } + }); + // Return with exit status 0 outside of the `forEach` loop, in case + // multiple regular expressions were passed in. + return process.exit(0); + }; + + main(); + +}()); diff --git a/tools/ui/node_modules/regjsparser/package.json b/tools/ui/node_modules/regjsparser/package.json new file mode 100644 index 0000000000000000000000000000000000000000..d32b6a779fa1aa50910f97842af60b7956a0da55 --- /dev/null +++ b/tools/ui/node_modules/regjsparser/package.json @@ -0,0 +1,47 @@ +{ + "name": "regjsparser", + "version": "0.13.1", + "author": "'Julian Viereck' ", + "license": "BSD-2-Clause", + "main": "./parser", + "types": "./parser.d.ts", + "bin": { + "regjsparser": "bin/parser" + }, + "homepage": "https://github.com/jviereck/regjsparser", + "repository": { + "type": "git", + "url": "git+ssh://git@github.com/jviereck/regjsparser.git" + }, + "scripts": { + "lint": "eslint --max-warnings 0 .", + "test": "run-p test:* lint", + "test:src": "node test/index.js", + "test:types": "tsc test/types.ts --noEmit", + "bench:baseline": "node ./tools/bench/index.mjs baseline", + "bench:current": "node ./tools/bench/index.mjs current", + "bench": "run-s bench:*" + }, + "files": [ + "bin/", + "LICENSE.BSD", + "parser.js", + "parser.d.ts", + "README.md" + ], + "dependencies": { + "jsesc": "~3.1.0" + }, + "devDependencies": { + "@eslint/js": "^10.0.1", + "@unicode/unicode-17.0.0": "^1.6.12", + "eslint": "^10.0.2", + "eslint-plugin-regexp": "^3.0.0", + "globals": "^17.3.0", + "npm-run-all": "^4.1.5", + "regenerate": "^1.4.2", + "regjsparser": "^0.11.2", + "tinybench": "^5.0.1", + "typescript": "~5.9.2" + } +} diff --git a/tools/ui/node_modules/regjsparser/parser.d.ts b/tools/ui/node_modules/regjsparser/parser.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..52253010ba7496ec825717696e0db0067c34818a --- /dev/null +++ b/tools/ui/node_modules/regjsparser/parser.d.ts @@ -0,0 +1,182 @@ +type _If = Test extends true ? Then : Else; + +export type Features = { + lookbehind?: boolean; + namedGroups?: boolean; + unicodePropertyEscape?: boolean; + unicodeSet?: boolean; + modifiers?: boolean; +}; + +export type AstNodeType = + | "alternative" + | "anchor" + | "characterClass" + | "characterClassEscape" + | "characterClassRange" + | "disjunction" + | "dot" + | "group" + | "quantifier" + | "reference" + | "unicodePropertyEscape" + | "value"; + +export type Base = { + range: [number, number]; + raw: string; + type: T; +}; + +export type AstNode = + | Alternative + | Anchor + | CharacterClass + | CharacterClassEscape + | CharacterClassRange + | Disjunction + | Dot + | Group + | Quantifier + | Reference + | _If + | Value; + +export type RootNode = Exclude< + AstNode, + CharacterClassRange +>; + +export type Anchor = Base<"anchor"> & { + kind: "boundary" | "end" | "not-boundary" | "start"; +}; + +export type CharacterClassEscape = Base<"characterClassEscape"> & { + value: 'd' | 'D' | 'w' | 'W' | 's' | 'S'; +}; + +export type Value = Base<"value"> & { + codePoint: number; + kind: + | "controlLetter" + | "hexadecimalEscape" + | "identifier" + | "null" + | "octal" + | "singleEscape" + | "symbol" + | "unicodeCodePointEscape" + | "unicodeEscape"; +}; + +export type Identifier = Base<"value"> & { + value: string; +}; + +export type Alternative = Base<"alternative"> & { + body: RootNode[]; +}; + +export type CharacterClassRange = Base<"characterClassRange"> & { + max: Value; + min: Value; +}; + +export type UnicodePropertyEscape = Base<"unicodePropertyEscape"> & { + negative: boolean; + value: string; +}; + +export type CharacterClassBody = + | CharacterClassEscape + | CharacterClassRange + | UnicodePropertyEscape + | Value; + +export type CharacterClass = Base<"characterClass"> & { + body: CharacterClassBody[]; + negative: boolean; + kind: "union" | _If; +}; + +export type ModifierFlags = { + enabling: string; + disabling: string; +}; + +export type NonCapturingGroup = Base<"group"> & + ( + | { + behavior: + | "lookahead" + | "lookbehind" + | "negativeLookahead" + | "negativeLookbehind"; + body: RootNode[]; + } + | ({ + behavior: "ignore"; + body: RootNode[]; + } & _If< + F["modifiers"], + { + modifierFlags?: ModifierFlags; + }, + { + modifierFlags: undefined; + } + >) + ); + +export type CapturingGroup = Base<"group"> & { + behavior: "normal"; + body: RootNode[]; +} & _If< + F["namedGroups"], + { + name?: Identifier; + }, + { + name: undefined; + } + >; + +export type Group = + | CapturingGroup + | NonCapturingGroup; + +export type Quantifier = Base<"quantifier"> & { + body: [RootNode]; + greedy: boolean; + max?: number; + min: number; + symbol?: "?" | "*" | "+"; +}; + +export type Disjunction = Base<"disjunction"> & { + body: [RootNode, RootNode, ...RootNode[]]; +}; + +export type Dot = Base<"dot">; + +export type NamedReference = Base<"reference"> & { + matchIndex: undefined; + name: Identifier; +}; + +export type IndexReference = Base<"reference"> & { + matchIndex: number; + name: undefined; +}; + +export type Reference = _If< + F["namedGroups"], + IndexReference | NamedReference, + IndexReference +>; + +export function parse( + str: string, + flags: string, + features?: F +): RootNode; diff --git a/tools/ui/node_modules/regjsparser/parser.js b/tools/ui/node_modules/regjsparser/parser.js new file mode 100644 index 0000000000000000000000000000000000000000..f383cc5ed1fabc0bae5dd5a36908ac586e92716c --- /dev/null +++ b/tools/ui/node_modules/regjsparser/parser.js @@ -0,0 +1,1823 @@ +// regjsparser +// +// ================================================================== +// +// See ECMA-262 Standard: 15.10.1 +// +// NOTE: The ECMA-262 standard uses the term "Assertion" for /^/. Here the +// term "Anchor" is used. +// +// Pattern :: +// Disjunction +// +// Disjunction :: +// Alternative +// Alternative | Disjunction +// +// Alternative :: +// [empty] +// Alternative Term +// +// Term :: +// Anchor +// Anchor Quantifier (see https://github.com/jviereck/regjsparser/issues/130) +// Atom +// Atom Quantifier +// +// Anchor :: +// ^ +// $ +// \ b +// \ B +// ( ? = Disjunction ) +// ( ? ! Disjunction ) +// ( ? < = Disjunction ) +// ( ? < ! Disjunction ) +// +// Quantifier :: +// QuantifierPrefix +// QuantifierPrefix ? +// +// QuantifierPrefix :: +// * +// + +// ? +// { DecimalDigits } +// { DecimalDigits , } +// { DecimalDigits , DecimalDigits } +// +// Atom :: +// PatternCharacter +// . +// \ AtomEscape +// CharacterClass +// ( GroupSpecifier Disjunction ) +// ( ? : Disjunction ) +// +// PatternCharacter :: +// SourceCharacter but not any of: ^ $ \ . * + ? ( ) [ ] { } | +// +// AtomEscape :: +// DecimalEscape +// CharacterClassEscape +// CharacterEscape +// k GroupName +// +// CharacterEscape[U] :: +// ControlEscape +// c ControlLetter +// HexEscapeSequence +// RegExpUnicodeEscapeSequence[?U] (ES6) +// IdentityEscape[?U] +// +// ControlEscape :: +// one of f n r t v +// ControlLetter :: +// one of +// a b c d e f g h i j k l m n o p q r s t u v w x y z +// A B C D E F G H I J K L M N O P Q R S T U V W X Y Z +// +// IdentityEscape :: +// SourceCharacter but not c +// +// DecimalEscape :: +// DecimalIntegerLiteral [lookahead ∉ DecimalDigit] +// +// CharacterClassEscape :: +// one of d D s S w W +// +// CharacterClass :: +// [ [lookahead ∉ {^}] ClassContents ] +// [ ^ ClassContents ] +// +// ClassContents :: +// [empty] +// [~V] NonemptyClassRanges +// [+V] ClassSetExpression +// +// NonemptyClassRanges :: +// ClassAtom +// ClassAtom NonemptyClassRangesNoDash +// ClassAtom - ClassAtom ClassContents +// +// NonemptyClassRangesNoDash :: +// ClassAtom +// ClassAtomNoDash NonemptyClassRangesNoDash +// ClassAtomNoDash - ClassAtom ClassContents +// +// ClassAtom :: +// - +// ClassAtomNoDash +// +// ClassAtomNoDash :: +// SourceCharacter but not one of \ or ] or - +// \ ClassEscape +// +// ClassEscape :: +// DecimalEscape +// b +// CharacterEscape +// CharacterClassEscape +// +// GroupSpecifier :: +// [empty] +// ? GroupName +// +// GroupName :: +// < RegExpIdentifierName > +// +// RegExpIdentifierName :: +// RegExpIdentifierStart +// RegExpIdentifierName RegExpIdentifierContinue +// +// RegExpIdentifierStart :: +// UnicodeIDStart +// $ +// _ +// \ RegExpUnicodeEscapeSequence +// +// RegExpIdentifierContinue :: +// UnicodeIDContinue +// $ +// _ +// \ RegExpUnicodeEscapeSequence +// +// +// +// -------------------------------------------------------------- +// NOTE: The following productions refer to the "set notation and +// properties of strings" proposal. +// https://github.com/tc39/proposal-regexp-set-notation +// -------------------------------------------------------------- +// +// ClassSetExpression :: +// ClassUnion +// ClassIntersection +// ClassSubtraction +// +// ClassUnion :: +// ClassSetRange ClassUnion? +// ClassSetOperand ClassUnion? +// +// ClassIntersection :: +// ClassSetOperand && [lookahead ≠ &] ClassSetOperand +// ClassIntersection && [lookahead ≠ &] ClassSetOperand +// +// ClassSubtraction :: +// ClassSetOperand -- ClassSetOperand +// ClassSubtraction -- ClassSetOperand +// +// ClassSetRange :: +// ClassSetCharacter - ClassSetCharacter +// +// ClassSetOperand :: +// ClassSetCharacter +// ClassStringDisjunction +// NestedClass +// +// NestedClass :: +// [ [lookahead ≠ ^] ClassContents[+U,+V] ] +// [ ^ ClassContents[+U,+V] ] +// \ CharacterClassEscape[+U, +V] +// +// ClassStringDisjunction :: +// \q{ ClassStringDisjunctionContents } +// +// ClassStringDisjunctionContents :: +// ClassString +// ClassString | ClassStringDisjunctionContents +// +// ClassString :: +// [empty] +// NonEmptyClassString +// +// NonEmptyClassString :: +// ClassSetCharacter NonEmptyClassString? +// +// ClassSetCharacter :: +// [lookahead ∉ ClassSetReservedDoublePunctuator] SourceCharacter but not ClassSetSyntaxCharacter +// \ CharacterEscape[+U] +// \ ClassSetReservedPunctuator +// \b +// +// ClassSetReservedDoublePunctuator :: +// one of && !! ## $$ %% ** ++ ,, .. :: ;; << == >> ?? @@ ^^ `` ~~ +// +// ClassSetSyntaxCharacter :: +// one of ( ) [ ] { } / - \ | +// +// ClassSetReservedPunctuator :: +// one of & - ! # % , : ; < = > @ ` ~ +// +// -------------------------------------------------------------- +// NOTE: The following productions refer to the +// "Regular Expression Pattern Modifiers for ECMAScript" proposal. +// https://github.com/tc39/proposal-regexp-modifiers +// -------------------------------------------------------------- +// +// Atom :: +// ( ? RegularExpressionModifiers : Disjunction ) +// ( ? RegularExpressionModifiers - RegularExpressionModifiers : Disjunction ) +// +// RegularExpressionModifiers: +// [empty] +// RegularExpressionModifiers RegularExpressionModifier +// +// RegularExpressionModifier: +// one of i m s + +"use strict"; +(function() { + + var fromCodePoint = String.fromCodePoint || (function() { + // Implementation taken from + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint + + var stringFromCharCode = String.fromCharCode; + var floor = Math.floor; + + return function fromCodePoint() { + var MAX_SIZE = 0x4000; + var codeUnits = []; + var highSurrogate; + var lowSurrogate; + var index = -1; + var length = arguments.length; + if (!length) { + return ''; + } + var result = ''; + while (++index < length) { + var codePoint = Number(arguments[index]); + if ( + !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity` + codePoint < 0 || // not a valid Unicode code point + codePoint > 0x10FFFF || // not a valid Unicode code point + floor(codePoint) != codePoint // not an integer + ) { + throw RangeError('Invalid code point: ' + codePoint); + } + if (codePoint <= 0xFFFF) { // BMP code point + codeUnits.push(codePoint); + } else { // Astral code point; split in surrogate halves + // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + codePoint -= 0x10000; + highSurrogate = (codePoint >> 10) + 0xD800; + lowSurrogate = (codePoint % 0x400) + 0xDC00; + codeUnits.push(highSurrogate, lowSurrogate); + } + if (index + 1 == length || codeUnits.length > MAX_SIZE) { + result += stringFromCharCode.apply(null, codeUnits); + codeUnits.length = 0; + } + } + return result; + }; + }()); + + function parse(str, flags, features) { + if (!features) { + features = {}; + } + + function updateRawStart(node, start) { + node.range[0] = start; + node.raw = str.substring(start, node.range[1]); + return node; + } + + function createAnchor(kind, rawLength) { + return { + type: 'anchor', + kind: kind, + range: [ + pos - rawLength, + pos + ], + raw: str.substring(pos - rawLength, pos) + }; + } + + function createValue(kind, codePoint, from, to) { + return { + type: 'value', + kind: kind, + codePoint: codePoint, + range: [from, to], + raw: str.substring(from, to) + }; + } + + function createEscaped(kind, codePoint, value, fromOffset) { + fromOffset = fromOffset || 0; + return createValue(kind, codePoint, pos - (value.length + fromOffset), pos); + } + + function createCharacter(matches) { + var _char = matches[0]; + var first = _char.charCodeAt(0); + if (isUnicodeMode) { + var second; + if (_char.length === 1 && first >= 0xD800 && first <= 0xDBFF) { + second = lookahead().charCodeAt(0); + if (second >= 0xDC00 && second <= 0xDFFF) { + // Unicode surrogate pair + pos++; + return createValue( + 'symbol', + (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000, + pos - 2, pos); + } + } + } + return createValue('symbol', first, pos - 1, pos); + } + + function createDisjunction(alternatives, from, to) { + return { + type: 'disjunction', + body: alternatives, + range: [ + from, + to + ], + raw: str.substring(from, to) + }; + } + + function createDot() { + return { + type: 'dot', + range: [ + pos - 1, + pos + ], + raw: '.' + }; + } + + function createCharacterClassEscape(value) { + return { + type: 'characterClassEscape', + value: value, + range: [ + pos - 2, + pos + ], + raw: str.substring(pos - 2, pos) + }; + } + + function createReference(matchIndex) { + var start = pos - 1 - matchIndex.length; + return { + type: 'reference', + matchIndex: parseInt(matchIndex, 10), + range: [ + start, + pos + ], + raw: str.substring(start, pos) + }; + } + + function createNamedReference(name) { + var start = name.range[0] - 3; + return { + type: 'reference', + name: name, + range: [ + start, + pos + ], + raw: str.substring(start, pos) + }; + } + + function createGroup(behavior, disjunction, from, to) { + return { + type: 'group', + behavior: behavior, + body: disjunction, + range: [ + from, + to + ], + raw: str.substring(from, to) + }; + } + + function createQuantifier(min, max, from, to, symbol) { + if (to == null) { + from = pos - 1; + to = pos; + } + + return { + type: 'quantifier', + min: min, + max: max, + greedy: true, + body: null, // set later on + symbol: symbol, + range: [ + from, + to + ], + raw: str.substring(from, to) + }; + } + + function createAlternative(terms, from, to) { + return { + type: 'alternative', + body: terms, + range: [ + from, + to + ], + raw: str.substring(from, to) + }; + } + + function createCharacterClass(contents, negative, from, to) { + return { + type: 'characterClass', + kind: contents.kind, + body: contents.body, + negative: negative, + range: [ + from, + to + ], + raw: str.substring(from, to) + }; + } + + function createClassRange(min, max, from, to) { + // See 15.10.2.15: + if (min.codePoint > max.codePoint) { + bail('invalid range in character class', min.raw + '-' + max.raw, from, to); + } + + return { + type: 'characterClassRange', + min: min, + max: max, + range: [ + from, + to + ], + raw: str.substring(from, to) + }; + } + + function createClassStrings(strings, from, to) { + return { + type: 'classStrings', + strings: strings, + range: [from, to], + raw: str.substring(from, to) + }; + } + + function createClassString(characters, from, to) { + return { + type: 'classString', + characters: characters, + range: [from, to], + raw: str.substring(from, to) + }; + } + + function flattenBody(body) { + if (body.type === 'alternative') { + return body.body; + } else { + return [body]; + } + } + + function incr(amount) { + amount = (amount || 1); + pos += amount; + } + + function consume(amount) { + var res = str.substring(pos, pos += amount); + return res; + } + + function skip(value) { + if (!match(value)) { + bail('character', value); + } + } + + function match(value) { + var len = value.length; + if (str.substring(pos, pos + len) === value) { + incr(len); + return value; + } + } + + function matchOne(value) { + if (str[pos] === value) { + pos++; + return value; + } + } + + function lookahead() { + return str[pos]; + } + + function currentOne(value) { + return str[pos] === value; + } + + function current(value) { + var len = value.length; + return str.substring(pos, pos + len) === value; + } + + function next(value) { + return str[pos + 1] === value; + } + + function matchReg(regExp) { + var subStr = str.substring(pos); + var res = subStr.match(regExp); + if (res) { + pos += res[0].length; + } + return res; + } + + function parseDisjunction() { + // Disjunction :: + // Alternative + // Alternative | Disjunction + var res = [], from = pos; + res.push(parseAlternative()); + + while (matchOne('|')) { + res.push(parseAlternative()); + } + + if (res.length === 1) { + return res[0]; + } + + return createDisjunction(res, from, pos); + } + + function parseAlternative() { + var res = [], from = pos; + var term; + + // Alternative :: + // [empty] + // Alternative Term + while (term = parseTerm()) { + res.push(term); + } + + if (res.length === 1) { + return res[0]; + } + + return createAlternative(res, from, pos); + } + + function parseTerm() { + // Term :: + // Anchor + // Atom + // Atom Quantifier + + // Term (Annex B):: + // [~UnicodeMode] QuantifiableAssertion Quantifier (see https://github.com/jviereck/regjsparser/issues/130) + // [~UnicodeMode] ExtendedAtom Quantifier + + // QuantifiableAssertion:: + // (?= Disjunction[~UnicodeMode, ~UnicodeSetsMode, ?NamedCaptureGroups] ) + // (?! Disjunction[~UnicodeMode, ~UnicodeSetsMode, ?NamedCaptureGroups] ) + + if (pos >= str.length || currentOne('|') || currentOne(')')) { + return null; /* Means: The term is empty */ + } + + var anchor = parseAnchor(); + var quantifier; + if (anchor) { + var pos_backup = pos; + quantifier = parseQuantifier() || false; + if (quantifier) { + // Annex B + if (!isUnicodeMode && anchor.type === "group") { + quantifier.body = flattenBody(anchor); + // The quantifier contains the anchor. Therefore, the beginning of the + // quantifier range is given by the beginning of the anchor. + updateRawStart(quantifier, anchor.range[0]); + return quantifier; + } + pos = pos_backup; + bail("Expected atom"); + } + return anchor; + } + + // If there is no Anchor, try to parse an atom. + var atom = parseAtomAndExtendedAtom(); + if (!atom) { + // Check if a quantifier is following. A quantifier without an atom + // is an error. + pos_backup = pos; + quantifier = parseQuantifier() || false; + if (quantifier) { + pos = pos_backup; + bail("Expected atom"); + } + + // If no unicode flag, then try to parse ExtendedAtom -> ExtendedPatternCharacter. + // ExtendedPatternCharacter + if (!isUnicodeMode && matchOne("{")) { + atom = createCharacter("{"); + } else { + bail("Expected atom"); + } + } + + quantifier = parseQuantifier() || false; + if (quantifier) { + var type = atom.type, behavior = atom.behavior; + if ( + type === "group" && + (behavior === "negativeLookbehind" || + behavior === "lookbehind") + ) { + bail( + "Invalid quantifier", + "", + quantifier.range[0], + quantifier.range[1] + ); + } + quantifier.body = flattenBody(atom); + // The quantifier contains the atom. Therefore, the beginning of the + // quantifier range is given by the beginning of the atom. + updateRawStart(quantifier, atom.range[0]); + return quantifier; + } + return atom; + } + + function parseGroup(matchA, typeA, matchB, typeB) { + var type, from = pos; + + if (match(matchA)) { + type = typeA; + } else if (match(matchB)) { + type = typeB; + } else { + return false; + } + + return finishGroup(type, from); + } + + function finishGroup(type, from) { + var body = parseDisjunction(); + if (!body) { + bail('Expected disjunction'); + } + skip(')'); + var group = createGroup(type, flattenBody(body), from, pos); + + if (type == 'normal') { + // Keep track of the number of closed groups. This is required for + // parseDecimalEscape(). In case the string is parsed a second time the + // value already holds the total count and no incrementation is required. + if (firstIteration) { + closedCaptureCounter++; + } + } + return group; + } + + function parseAnchor() { + // Anchor :: + // ^ + // $ + // \ b + // \ B + // ( ? = Disjunction ) + // ( ? ! Disjunction ) + + switch(lookahead()) { + case '^': + incr(); + return createAnchor('start', 1 /* rawLength */); + case '$': + incr(); + return createAnchor('end', 1 /* rawLength */); + case '\\': { + if (next('b')) { + incr(2); + return createAnchor('boundary', 2 /* rawLength */); + } else if (next('B')) { + incr(2); + return createAnchor('not-boundary', 2 /* rawLength */); + } + break; + } + case '(': + return parseGroup('(?=', 'lookahead', '(?!', 'negativeLookahead'); + default: + return; + } + } + + function parseQuantifier() { + // Quantifier :: + // QuantifierPrefix + // QuantifierPrefix ? + // + // QuantifierPrefix :: + // * + // + + // ? + // { DecimalDigits } + // { DecimalDigits , } + // { DecimalDigits , DecimalDigits } + + var res, from = pos; + var quantifier; + var min, max; + + switch(lookahead()) { + case '*': + incr(); + quantifier = createQuantifier(0, undefined, undefined, undefined, '*'); + break; + case '+': + incr(); + quantifier = createQuantifier(1, undefined, undefined, undefined, "+"); + break; + case '?': + incr(); + quantifier = createQuantifier(0, 1, undefined, undefined, "?"); + break; + case '{': { + if (res = matchReg(/^\{(\d+)\}/)) { + min = parseInt(res[1], 10); + quantifier = createQuantifier(min, min, from, pos); + } + else if (res = matchReg(/^\{(\d+),\}/)) { + min = parseInt(res[1], 10); + quantifier = createQuantifier(min, undefined, from, pos); + } + else if (res = matchReg(/^\{(\d+),(\d+)\}/)) { + min = parseInt(res[1], 10); + max = parseInt(res[2], 10); + if (min > max) { + bail('numbers out of order in {} quantifier', '', from, pos); + } + quantifier = createQuantifier(min, max, from, pos); + } + + if (min && (!Number.isSafeInteger(min)) || (max && !Number.isSafeInteger(max))) { + bail("iterations outside JS safe integer range in quantifier", "", from, pos); + } + } + } + + if (quantifier) { + if (matchOne('?')) { + quantifier.greedy = false; + quantifier.range[1] += 1; + } + } + + return quantifier; + } + + function parseAtomAndExtendedAtom() { + // Parsing Atom and ExtendedAtom together due to redundancy. + // ExtendedAtom is defined in Appendix B of the ECMA-262 standard. + // + // SEE: https://www.ecma-international.org/ecma-262/10.0/index.html#prod-annexB-ExtendedPatternCharacter + // + // Atom :: + // PatternCharacter + // . + // \ AtomEscape + // CharacterClass + // ( GroupSpecifier Disjunction ) + // ( ? RegularExpressionModifiers : Disjunction ) + // ( ? RegularExpressionModifiers - RegularExpressionModifiers : Disjunction ) + // ExtendedAtom :: + // ExtendedPatternCharacter + // ExtendedPatternCharacter :: + // SourceCharacter but not one of ^$\.*+?()[| + + var res; + + switch (res = lookahead()) { + case '.': + // . + incr(); + return createDot(); + case '\\': { + // \ AtomEscape + incr(); + res = parseAtomEscape(); + if (!res) { + if (!isUnicodeMode && lookahead() == 'c') { + // B.1.4 ExtendedAtom + // \[lookahead = c] + return createValue('symbol', 92, pos - 1, pos); + } + bail('atomEscape'); + } + return res; + } + case '[': + return parseCharacterClass(); + case '(': { + if (features.lookbehind && (res = parseGroup('(?<=', 'lookbehind', '(?"); + var group = finishGroup("normal", name.range[0] - 3); + group.name = name; + return group; + } + else if (features.modifiers && current("(?") && str[pos + 2] != ":") { + return parseModifiersGroup(); + } + else { + // ( Disjunction ) + // ( ? : Disjunction ) + return parseGroup('(?:', 'ignore', '(', 'normal'); + } + } + case ']': + case '}': + // ExtendedPatternCharacter, first part. See parseTerm. + if (!isUnicodeMode) { + incr(); + return createCharacter(res); + } + break; + case '^': + case '$': + case '*': + case '+': + case '?': + case '{': + case ')': + case '|': + break; + default: + // PatternCharacter + incr(); + return createCharacter(res); + } + } + + function parseModifiersGroup() { + function hasDupChar(str) { + var i = 0; + while (i < str.length) { + if (str.indexOf(str[i], i + 1) != -1) { + return true; + } + i++; + } + return false; + } + + var from = pos; + incr(2); + + var enablingFlags = matchReg(/^[sim]+/); + var disablingFlags; + if(matchOne("-") && lookahead() !== ":"){ + disablingFlags = matchReg(/^[sim]+/); + if (!disablingFlags) { + bail('Invalid flags for modifiers group'); + } + } else if(!enablingFlags){ + bail('Invalid flags for modifiers group'); + } + + enablingFlags = enablingFlags ? enablingFlags[0] : ""; + disablingFlags = disablingFlags ? disablingFlags[0] : ""; + + var flags = enablingFlags + disablingFlags; + if(flags.length > 3 || hasDupChar(flags)) { + bail('flags cannot be duplicated for modifiers group'); + } + + if(!matchOne(":")) { + bail('Invalid flags for modifiers group'); + } + + var modifiersGroup = finishGroup("ignore", from); + + modifiersGroup.modifierFlags = { + enabling: enablingFlags, + disabling: disablingFlags + }; + + return modifiersGroup; + } + + function parseUnicodeSurrogatePairEscape(firstEscape, isUnicodeMode) { + if (isUnicodeMode) { + var first, second; + if (firstEscape.kind == 'unicodeEscape' && + (first = firstEscape.codePoint) >= 0xD800 && first <= 0xDBFF && + currentOne('\\') && next('u') ) { + var prevPos = pos; + pos++; + var secondEscape = parseClassEscape(); + if (secondEscape.kind == 'unicodeEscape' && + (second = secondEscape.codePoint) >= 0xDC00 && second <= 0xDFFF) { + // Unicode surrogate pair + firstEscape.kind = 'unicodeCodePointEscape'; + firstEscape.codePoint = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; + firstEscape.range[1] = pos; + firstEscape.raw = str.substring(firstEscape.range[0], pos) + } + else { + pos = prevPos; + } + } + } + return firstEscape; + } + + function parseClassEscape() { + return parseAtomEscape(true); + } + + function parseAtomEscape(insideCharacterClass) { + // AtomEscape :: + // DecimalEscape + // CharacterEscape + // CharacterClassEscape + // k GroupName + + var res, from = pos, ch; + + switch (ch = lookahead()) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + return parseDecimalEscape(insideCharacterClass); + case 'B': { + if (insideCharacterClass) { + bail('\\B not possible inside of CharacterClass', '', from); + break; + } else { + return parseIdentityEscape(); + } + } + case 'b': { + if (insideCharacterClass) { + // 15.10.2.19 + // The production ClassEscape :: b evaluates by returning the + // CharSet containing the one character (Unicode value 0008). + incr(); + return createEscaped('singleEscape', 0x0008, '\\b'); + } else { + return parseIdentityEscape(); + } + } + case 'c': { + if (insideCharacterClass) { + if (!isUnicodeMode && (res = matchReg(/^c(\d)/))) { + // B.1.4 + // c ClassControlLetter, ClassControlLetter = DecimalDigit + return createEscaped('controlLetter', res[1] + 16, res[1], 2); + } else if (!isUnicodeMode && match("c_")) { + // B.1.4 + // c ClassControlLetter, ClassControlLetter = _ + return createEscaped('controlLetter', 31, '_', 2); + } + } + return parseCharacterEscape(); + } + // CharacterClassEscape :: one of d D s S w W + case 'd': + case 'D': + case 'w': + case 'W': + case 's': + case 'S': + incr(); + return createCharacterClassEscape(ch); + case 'k': + return parseNamedReference() || parseIdentityEscape(); + case 'p': + case 'P': + return parseUnicodePropertyEscape() || parseIdentityEscape(); + case '-': { + // [+U] - + if (insideCharacterClass && isUnicodeMode) { + incr(); + return createEscaped('singleEscape', 0x002d, '\\-'); + } + return parseIdentityEscape(); + } + default: + return parseCharacterEscape(); + } + } + + + function parseDecimalEscape(insideCharacterClass) { + // DecimalEscape :: + // DecimalIntegerLiteral [lookahead ∉ DecimalDigit] + + var res, match, from = pos; + + if (res = matchReg(/^(?!0)\d+/)) { + match = res[0]; + var refIdx = parseInt(match, 10); + if (refIdx <= closedCaptureCounter && !insideCharacterClass) { + // If the number is smaller than the normal-groups found so + // far, then it is a reference... + return createReference(match); + } else { + // ... otherwise it needs to be interpreted as a octal (if the + // number is in an octal format). If it is NOT octal format, + // then the slash is ignored and the number is matched later + // as normal characters. + + // Recall the negative decision to decide if the input must be parsed + // a second time with the total normal-groups. + backrefDenied.push(refIdx); + + // \1 octal escapes are disallowed in unicode mode, but they might + // be references to groups which haven't been parsed yet. + // We must parse a second time to determine if \1 is a reference + // or an octal scape, and then we can report the error. + if (firstIteration) { + shouldReparse = true; + } else { + bailOctalEscapeIfUnicode(from, pos); + } + + // Reset the position again, as maybe only parts of the previous + // matched numbers are actual octal numbers. E.g. in '019' only + // the '01' should be matched. + incr(-match.length); + if (res = matchReg(/^[0-7]{1,3}/)) { + return createEscaped('octal', parseInt(res[0], 8), res[0], 1); + } else { + // If we end up here, we have a case like /\91/. Then the + // first slash is to be ignored and the 9 & 1 to be treated + // like ordinary characters. Create a character for the + // first number only here - other number-characters + // (if available) will be matched later. + var start = pos; + res = createCharacter(matchReg(/^[89]/)); + return updateRawStart(res, start - 1); + } + } + } + // Only allow octal numbers in the following. All matched numbers start + // with a zero (if the do not, the previous if-branch is executed). + // If the number is not octal format and starts with zero (e.g. `091`) + // then only the zeros `0` is treated here and the `91` are ordinary + // characters. + // Example: + // /\091/.exec('\091')[0].length === 3 + else if (res = matchReg(/^[0-7]{1,3}/)) { + match = res[0]; + if (match !== '0') { + bailOctalEscapeIfUnicode(from, pos); + } + if (/^0{1,3}$/.test(match)) { + // If they are all zeros, then only take the first one. + return createEscaped('null', 0x0000, '0', match.length); + } else { + return createEscaped('octal', parseInt(match, 8), match, 1); + } + } + return false; + } + + function bailOctalEscapeIfUnicode(from, pos) { + if (isUnicodeMode) { + bail("Invalid decimal escape in unicode mode", null, from, pos); + } + } + + function parseUnicodePropertyEscape() { + var res, from = pos; + if (features.unicodePropertyEscape && isUnicodeMode && (res = matchReg(/^([pP])\{([^}]+)\}/))) { + // https://github.com/jviereck/regjsparser/issues/77 + return { + type: 'unicodePropertyEscape', + negative: res[1] === 'P', + value: res[2], + range: [from - 1, pos], + raw: str.substring(from - 1, pos) + }; + } + return false; + } + + function parseNamedReference() { + if (features.namedGroups && matchReg(/^k<(?=.*?>)/)) { + var name = parseIdentifier(); + skip('>'); + return createNamedReference(name); + } + } + + function parseRegExpUnicodeEscapeSequence(isUnicodeMode) { + var res; + if (res = matchReg(/^u([0-9a-fA-F]{4})/)) { + // UnicodeEscapeSequence + return parseUnicodeSurrogatePairEscape( + createEscaped('unicodeEscape', parseInt(res[1], 16), res[1], 2), + isUnicodeMode + ); + } else if (isUnicodeMode && (res = matchReg(/^u\{([0-9a-fA-F]+)\}/))) { + // RegExpUnicodeEscapeSequence (ES6 Unicode code point escape) + return createEscaped('unicodeCodePointEscape', parseInt(res[1], 16), res[1], 4); + } + } + + function parseCharacterEscape() { + // CharacterEscape :: + // ControlEscape + // c ControlLetter + // HexEscapeSequence + // UnicodeEscapeSequence[?UnicodeMode] + // IdentityEscape[?UnicodeMode] + + var res; + var from = pos; + switch (lookahead()) { + case 't': + incr(); + return createEscaped('singleEscape', 0x009, '\\t'); + case 'n': + incr(); + return createEscaped('singleEscape', 0x00A, '\\n'); + case 'v': + incr(); + return createEscaped('singleEscape', 0x00B, '\\v'); + case 'f': + incr(); + return createEscaped('singleEscape', 0x00C, '\\f'); + case 'r': + incr(); + return createEscaped('singleEscape', 0x00D, '\\r'); + case 'c': + if (res = matchReg(/^c([a-zA-Z])/)) { + // c ControlLetter + return createEscaped('controlLetter', res[1].charCodeAt(0) % 32, res[1], 2); + } + break; + case 'x': + if (res = matchReg(/^x([0-9a-fA-F]{2})/)) { + // HexEscapeSequence + return createEscaped('hexadecimalEscape', parseInt(res[1], 16), res[1], 2); + } + break; + case 'u': + if (res = parseRegExpUnicodeEscapeSequence(isUnicodeMode)) { + if (!res || res.codePoint > 0x10FFFF) { + bail('Invalid escape sequence', null, from, pos); + } + return res; + } + break; + } + // IdentityEscape + return parseIdentityEscape(); + } + + function parseIdentifierAtom(check) { + // RegExpIdentifierStart[UnicodeMode] :: + // IdentifierStartChar + // \ RegExpUnicodeEscapeSequence[+UnicodeMode] + // [~UnicodeMode] UnicodeLeadSurrogate UnicodeTrailSurrogate + // + // RegExpIdentifierPart[UnicodeMode] :: + // IdentifierPartChar + // \ RegExpUnicodeEscapeSequence[+UnicodeMode] + // [~UnicodeMode] UnicodeLeadSurrogate UnicodeTrailSurrogate + + + var ch = lookahead(); + var from = pos; + if (ch === '\\') { + incr(); + var esc = parseRegExpUnicodeEscapeSequence(true); + if (!esc || !check(esc.codePoint)) { + bail('Invalid escape sequence', null, from, pos); + } + return fromCodePoint(esc.codePoint); + } + var code = ch.charCodeAt(0); + if (code >= 0xD800 && code <= 0xDBFF) { + ch += str[pos + 1]; + var second = ch.charCodeAt(1); + if (second >= 0xDC00 && second <= 0xDFFF) { + // Unicode surrogate pair + code = (code - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; + } + } + if (!check(code)) return; + incr(); + if (code > 0xFFFF) incr(); + return ch; + } + + function parseIdentifier() { + // RegExpIdentifierName :: + // RegExpIdentifierStart + // RegExpIdentifierName RegExpIdentifierContinue + // + // RegExpIdentifierStart :: + // UnicodeIDStart + // $ + // _ + // \ RegExpUnicodeEscapeSequence + // + // RegExpIdentifierContinue :: + // UnicodeIDContinue + // $ + // _ + // \ RegExpUnicodeEscapeSequence + // + // + + var start = pos; + var res = parseIdentifierAtom(isIdentifierStart); + if (!res) { + bail('Invalid identifier'); + } + + var ch; + while (ch = parseIdentifierAtom(isIdentifierPart)) { + res += ch; + } + + return { + type: 'identifier', + value: res, + range: [start, pos], + raw: str.substring(start, pos) + }; + } + + function isIdentifierStart(ch) { + // ECMAScript (Unicode v17.0.0) NonAsciiIdentifierStart: + // Generated by `tools/generate-identifier-regex.js`. + + var NonAsciiIdentifierStart = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088F\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5C\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDC-\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C8A\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7DC\uA7F1-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDD70-\uDD7A\uDD7C-\uDD8A\uDD8C-\uDD92\uDD94\uDD95\uDD97-\uDDA1\uDDA3-\uDDB1\uDDB3-\uDDB9\uDDBB\uDDBC\uDDC0-\uDDF3\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67\uDF80-\uDF85\uDF87-\uDFB0\uDFB2-\uDFBA]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD40-\uDD59\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDD00-\uDD23\uDD4A-\uDD65\uDD6F-\uDD85\uDE80-\uDEA9\uDEB0\uDEB1\uDEC2-\uDEC7\uDF00-\uDF1C\uDF27\uDF30-\uDF45\uDF70-\uDF81\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC71\uDC72\uDC75\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE3F\uDE40\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61\uDF80-\uDF89\uDF8B\uDF8E\uDF90-\uDFB5\uDFB7\uDFD1\uDFD3]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDEB8\uDF00-\uDF1A\uDF40-\uDF46]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCDF\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEB0-\uDEF8\uDFC0-\uDFE0]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDDB0-\uDDDB\uDEE0-\uDEF2\uDF02\uDF04-\uDF10\uDF12-\uDF33\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|\uD80B[\uDF90-\uDFF0]|[\uD80C\uD80E\uD80F\uD81C-\uD822\uD840-\uD868\uD86A-\uD86D\uD86F-\uD872\uD874-\uD879\uD880-\uD883\uD885-\uD88C][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2F\uDC41-\uDC46\uDC60-\uDFFF]|\uD810[\uDC00-\uDFFA]|\uD811[\uDC00-\uDE46]|\uD818[\uDD00-\uDD1D]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE70-\uDEBE\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDD40-\uDD6C\uDE40-\uDE7F\uDEA0-\uDEB8\uDEBB-\uDED3\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3\uDFF2-\uDFF6]|\uD823[\uDC00-\uDCD5\uDCFF-\uDD1E\uDD80-\uDDF2]|\uD82B[\uDFF0-\uDFF3\uDFF5-\uDFFB\uDFFD\uDFFE]|\uD82C[\uDC00-\uDD22\uDD32\uDD50-\uDD52\uDD55\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD837[\uDF00-\uDF1E\uDF25-\uDF2A]|\uD838[\uDC30-\uDC6D\uDD00-\uDD2C\uDD37-\uDD3D\uDD4E\uDE90-\uDEAD\uDEC0-\uDEEB]|\uD839[\uDCD0-\uDCEB\uDDD0-\uDDED\uDDF0\uDEC0-\uDEDE\uDEE0-\uDEE2\uDEE4\uDEE5\uDEE7-\uDEED\uDEF0-\uDEF4\uDEFE\uDEFF\uDFE0-\uDFE6\uDFE8-\uDFEB\uDFED\uDFEE\uDFF0-\uDFFE]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43\uDD4B]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEAD\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0\uDFF0-\uDFFF]|\uD87B[\uDC00-\uDE5D]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A\uDF50-\uDFFF]|\uD88D[\uDC00-\uDC79]/; + return (ch === 36) || (ch === 95) || // $ (dollar) and _ (underscore) + (ch >= 65 && ch <= 90) || // A..Z + (ch >= 97 && ch <= 122) || // a..z + ((ch >= 0x80) && NonAsciiIdentifierStart.test(fromCodePoint(ch))); + } + + // Taken from the Esprima parser. + function isIdentifierPart(ch) { + // ECMAScript (Unicode v17.0.0) NonAsciiIdentifierPartOnly: + // Generated by `tools/generate-identifier-regex.js`. + // eslint-disable-next-line no-misleading-character-class + var NonAsciiIdentifierPartOnly = /[\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0897-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u180F-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF-\u1ADD\u1AE0-\u1AEB\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\u30FB\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F\uFF65]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD801[\uDCA0-\uDCA9]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDD30-\uDD39\uDD40-\uDD49\uDD69-\uDD6D\uDEAB\uDEAC\uDEFA-\uDEFF\uDF46-\uDF50\uDF82-\uDF85]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC66-\uDC70\uDC73\uDC74\uDC7F-\uDC82\uDCB0-\uDCBA\uDCC2\uDCF0-\uDCF9\uDD00-\uDD02\uDD27-\uDD34\uDD36-\uDD3F\uDD45\uDD46\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDDC9-\uDDCC\uDDCE-\uDDD9\uDE2C-\uDE37\uDE3E\uDE41\uDEDF-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF3B\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74\uDFB8-\uDFC0\uDFC2\uDFC5\uDFC7-\uDFCA\uDFCC-\uDFD0\uDFD2\uDFE1\uDFE2]|\uD805[\uDC35-\uDC46\uDC50-\uDC59\uDC5E\uDCB0-\uDCC3\uDCD0-\uDCD9\uDDAF-\uDDB5\uDDB8-\uDDC0\uDDDC\uDDDD\uDE30-\uDE40\uDE50-\uDE59\uDEAB-\uDEB7\uDEC0-\uDEC9\uDED0-\uDEE3\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDC2C-\uDC3A\uDCE0-\uDCE9\uDD30-\uDD35\uDD37\uDD38\uDD3B-\uDD3E\uDD40\uDD42\uDD43\uDD50-\uDD59\uDDD1-\uDDD7\uDDDA-\uDDE0\uDDE4\uDE01-\uDE0A\uDE33-\uDE39\uDE3B-\uDE3E\uDE47\uDE51-\uDE5B\uDE8A-\uDE99\uDF60-\uDF67\uDFF0-\uDFF9]|\uD807[\uDC2F-\uDC36\uDC38-\uDC3F\uDC50-\uDC59\uDC92-\uDCA7\uDCA9-\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD50-\uDD59\uDD8A-\uDD8E\uDD90\uDD91\uDD93-\uDD97\uDDA0-\uDDA9\uDDE0-\uDDE9\uDEF3-\uDEF6\uDF00\uDF01\uDF03\uDF34-\uDF3A\uDF3E-\uDF42\uDF50-\uDF5A]|\uD80D[\uDC40\uDC47-\uDC55]|\uD818[\uDD1E-\uDD39]|\uD81A[\uDE60-\uDE69\uDEC0-\uDEC9\uDEF0-\uDEF4\uDF30-\uDF36\uDF50-\uDF59]|\uD81B[\uDD70-\uDD79\uDF4F\uDF51-\uDF87\uDF8F-\uDF92\uDFE4\uDFF0\uDFF1]|\uD82F[\uDC9D\uDC9E]|\uD833[\uDCF0-\uDCF9\uDF00-\uDF2D\uDF30-\uDF46]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDC8F\uDD30-\uDD36\uDD40-\uDD49\uDEAE\uDEEC-\uDEF9]|\uD839[\uDCEC-\uDCF9\uDDEE\uDDEF\uDDF1-\uDDFA\uDEE3\uDEE6\uDEEE\uDEEF\uDEF5]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A\uDD50-\uDD59]|\uD83E[\uDFF0-\uDFF9]|\uDB40[\uDD00-\uDDEF]/; + return isIdentifierStart(ch) || + (ch >= 48 && ch <= 57) || // 0..9 + ((ch >= 0x80) && NonAsciiIdentifierPartOnly.test(fromCodePoint(ch))); + } + + function parseIdentityEscape() { + // IdentityEscape :: + // [+U] SyntaxCharacter + // [+U] / + // [~U] SourceCharacterIdentityEscape[?N] + // SourceCharacterIdentityEscape[?N] :: + // [~N] SourceCharacter but not c + // [+N] SourceCharacter but not one of c or k + + + var tmp; + var l = lookahead(); + if ( + (isUnicodeMode && /[\^$.*+?()\\[\]{}|/]/.test(l)) || + (!isUnicodeMode && l !== "c") + ) { + if (l === "k" && features.lookbehind) { + return null; + } + tmp = consume(1); + return createEscaped('identifier', tmp.charCodeAt(0), tmp, 1); + } + + return null; + } + + function parseCharacterClass() { + // CharacterClass :: + // [ [lookahead ∉ {^}] ClassContents ] + // [ ^ ClassContents ] + + var res, from = pos; + if (match("[^")) { + res = parseClassContents(); + skip(']'); + return createCharacterClass(res, true, from, pos); + } else if (matchOne('[')) { + res = parseClassContents(); + skip(']'); + return createCharacterClass(res, false, from, pos); + } + + return null; + } + + function parseClassContents() { + // ClassContents :: + // [empty] + // [~V] NonemptyClassRanges + // [+V] ClassSetExpression + + var res; + if (currentOne(']')) { + // Empty array means nothing inside of the ClassRange. + return { kind: 'union', body: [] }; + } else if (hasUnicodeSetFlag) { + return parseClassSetExpression(); + } else { + res = parseNonemptyClassRanges(); + if (!res) { + bail('nonEmptyClassRanges'); + } + return { kind: 'union', body: res }; + } + } + + function parseHelperClassContents(atom) { + var from, to, res, atomTo, dash; + if (currentOne('-') && !next(']')) { + // ClassAtom - ClassAtom ClassContents + from = atom.range[0]; + incr(); + dash = createCharacter('-'); + + atomTo = parseClassAtom(); + if (!atomTo) { + bail('classAtom'); + } + to = pos; + + // Parse the next class range if exists. + var classContents = parseClassContents(); + if (!classContents) { + bail('classContents'); + } + + // Check if both the from and atomTo have codePoints. + if (!('codePoint' in atom) || !('codePoint' in atomTo)) { + if (!isUnicodeMode) { + // If not, don't create a range but treat them as + // `atom` `-` `atom` instead. + // + // SEE: https://tc39.es/ecma262/#sec-regular-expression-patterns-semantics + // NonemptyClassRanges::ClassAtom - ClassAtom ClassContents + // CharacterRangeOrUnion + res = [atom, dash, atomTo]; + } else { + // With unicode flag, both sides must have codePoints if + // one side has a codePoint. + // + // SEE: https://tc39.es/ecma262/#sec-patterns-static-semantics-early-errors + // NonemptyClassRanges :: ClassAtom - ClassAtom ClassContents + bail('invalid character class'); + } + } else { + res = [createClassRange(atom, atomTo, from, to)]; + } + + if (classContents.type === 'empty') { + return res; + } + return res.concat(classContents.body); + } + + res = parseNonemptyClassRangesNoDash(); + if (!res) { + bail('nonEmptyClassRangesNoDash'); + } + + return [atom].concat(res); + } + + function parseNonemptyClassRanges() { + // NonemptyClassRanges :: + // ClassAtom + // ClassAtom NonemptyClassRangesNoDash + // ClassAtom - ClassAtom ClassContents + + var atom = parseClassAtom(); + if (!atom) { + bail('classAtom'); + } + + if (currentOne(']')) { + // ClassAtom + return [atom]; + } + + // ClassAtom NonemptyClassRangesNoDash + // ClassAtom - ClassAtom ClassContents + return parseHelperClassContents(atom); + } + + function parseNonemptyClassRangesNoDash() { + // NonemptyClassRangesNoDash :: + // ClassAtom + // ClassAtomNoDash NonemptyClassRangesNoDash + // ClassAtomNoDash - ClassAtom ClassContents + + var res = parseClassAtom(); + if (!res) { + bail('classAtom'); + } + if (currentOne(']')) { + // ClassAtom + return res; + } + + // ClassAtomNoDash NonemptyClassRangesNoDash + // ClassAtomNoDash - ClassAtom ClassContents + return parseHelperClassContents(res); + } + + function parseClassAtom() { + // ClassAtom :: + // - + // ClassAtomNoDash + if (matchOne('-')) { + return createCharacter('-'); + } else { + return parseClassAtomNoDash(); + } + } + + function parseClassAtomNoDash() { + // ClassAtomNoDash :: + // SourceCharacter but not one of \ or ] or - + // \ ClassEscape + // + // ClassAtomNoDash (Annex B):: + // \ [lookahead = c] + + var res; + switch ((res = lookahead())) { + case "\\": { + incr(); + res = parseClassEscape(); + if (!res) { + if (!isUnicodeMode && lookahead() == "c") { + return createCharacter("\\"); + } + bail("classEscape"); + } + + return parseUnicodeSurrogatePairEscape(res, isUnicodeMode); + } + case "]": + case "-": + break; + default: + incr(); + return createCharacter(res); + } + } + + function parseClassSetExpression() { + // ClassSetExpression :: + // ClassUnion + // ClassIntersection + // ClassSubtraction + // + // ClassUnion :: + // ClassSetRange ClassUnion? + // ClassSetOperand ClassUnion? + // + // ClassIntersection :: + // ClassSetOperand && [lookahead ≠ &] ClassSetOperand + // ClassIntersection && [lookahead ≠ &] ClassSetOperand + // + // ClassSubtraction :: + // ClassSetOperand -- ClassSetOperand + // ClassSubtraction -- ClassSetOperand + // + + var body = []; + var kind; + + var operand = parseClassSetOperand(/* allowRanges*/ true); + body.push(operand); + + if (operand.type === 'classRange') { + kind = 'union'; + } else if (currentOne('&')) { + kind = 'intersection'; + } else if (currentOne('-')) { + kind = 'subtraction'; + } else { + kind = 'union'; + } + + while (!currentOne(']')) { + if (kind === 'intersection') { + skip('&'); + skip('&'); + if (currentOne('&')) { + bail('&& cannot be followed by &. Wrap it in brackets: &&[&].'); + } + } else if (kind === 'subtraction') { + skip('-'); + skip('-'); + } + + operand = parseClassSetOperand(/* allowRanges*/ kind === 'union'); + body.push(operand); + } + + return { kind: kind, body: body }; + } + + function parseClassSetOperand(allowRanges) { + // ClassSetOperand :: + // ClassSetCharacter + // ClassStringDisjunction + // NestedClass + // + // NestedClass :: + // [ [lookahead ≠ ^] ClassContents[+U,+V] ] + // [ ^ ClassContents[+U,+V] ] + // \ CharacterClassEscape[+U, +V] + // + // ClassSetRange :: + // ClassSetCharacter - ClassSetCharacter + // + // ClassSetCharacter :: + // [lookahead ∉ ClassReservedDouble] SourceCharacter but not ClassSetSyntaxCharacter + // \ CharacterEscape[+U] + // \ ClassHalfOfDouble + // \ b + // + // ClassSyntaxCharacter :: + // one of ( ) [ ] { } / - \ | + + var from = pos; + var start, res; + + if (matchOne('\\')) { + // ClassSetOperand :: + // ... + // ClassStringDisjunction + // NestedClass + // + // NestedClass :: + // ... + // \ CharacterClassEscape[+U, +V] + if (match('q{')) { + return parseClassStringDisjunction(); + } else if (res = parseClassEscape()) { + start = res; + } else if (res = parseClassSetCharacterEscapedHelper()) { + return res; + } else { + bail('Invalid escape', '\\' + lookahead(), from); + } + } else if (res = parseClassSetCharacterUnescapedHelper()) { + start = res; + } else if (res = parseCharacterClass()) { + // ClassSetOperand :: + // ... + // NestedClass + // + // NestedClass :: + // [ [lookahead ≠ ^] ClassContents[+U,+V] ] + // [ ^ ClassContents[+U,+V] ] + // ... + return res; + } else { + bail('Invalid character', lookahead()); + } + + if (allowRanges && currentOne('-') && !next('-')) { + incr(); + + if (res = parseClassSetCharacter()) { + // ClassSetRange :: + // ClassSetCharacter - ClassSetCharacter + return createClassRange(start, res, from, pos); + } + + bail('Invalid range end', lookahead()); + } + + // ClassSetOperand :: + // ClassSetCharacter + // ... + return start; + } + + function parseClassSetCharacter() { + // ClassSetCharacter :: + // [lookahead ∉ ClassReservedDouble] SourceCharacter but not ClassSetSyntaxCharacter + // \ CharacterEscape[+U] + // \ ClassHalfOfDouble + // \ b + + if (matchOne('\\')) { + var res, from = pos; + if (res = parseClassSetCharacterEscapedHelper()) { + return res; + } else { + bail('Invalid escape', '\\' + lookahead(), from); + } + } + + return parseClassSetCharacterUnescapedHelper(); + } + + function parseClassSetCharacterUnescapedHelper() { + // ClassSetCharacter :: + // [lookahead ∉ ClassSetReservedDoublePunctuator] SourceCharacter but not ClassSetSyntaxCharacter + // ... + + var res; + if (matchReg(/^(?:&&|!!|##|\$\$|%%|\*\*|\+\+|,,|\.\.|::|;;|<<|==|>>|\?\?|@@|\^\^|``|~~)/)) { + bail('Invalid set operation in character class'); + } + if (res = matchReg(/^[^()[\]{}/\-\\|]/)) { + return createCharacter(res); + } + } + + function parseClassSetCharacterEscapedHelper() { + // ClassSetCharacter :: + // ... + // \ CharacterEscape[+U] + // \ ClassSetReservedPunctuator + // \ b + + var res; + if (matchOne('b')) { + return createEscaped('singleEscape', 0x0008, '\\b'); + } else if (matchOne('B')) { + bail('\\B not possible inside of ClassContents', '', pos - 2); + } else if (res = matchReg(/^[&\-!#%,:;<=>@`~]/)) { + return createEscaped('identifier', res[0].codePointAt(0), res[0]); + } else if (res = parseCharacterEscape()) { + return res; + } else { + return null; + } + } + + function parseClassStringDisjunction() { + // ClassStringDisjunction :: + // \q{ ClassStringDisjunctionContents } + // + // ClassStringDisjunctionContents :: + // ClassString + // ClassString | ClassStringDisjunctionContents + + + // When calling this function, \q{ has already been consumed. + var from = pos - 3; + + var res = []; + do { + res.push(parseClassString()); + } while (matchOne('|')); + + skip('}'); + + return createClassStrings(res, from, pos); + } + + function parseClassString() { + // ClassString :: + // [empty] + // NonEmptyClassString + // + // NonEmptyClassString :: + // ClassSetCharacter NonEmptyClassString? + + var res = [], from = pos; + var char; + + while (char = parseClassSetCharacter()) { + res.push(char); + } + + return createClassString(res, from, pos); + } + + function bail(message, details, from, to) { + from = from == null ? pos : from; + to = to == null ? from : to; + + var contextStart = Math.max(0, from - 10); + var contextEnd = Math.min(to + 10, str.length); + + // Output a bit of context and a line pointing to where our error is. + // + // We are assuming that there are no actual newlines in the content as this is a regular expression. + var context = ' ' + str.substring(contextStart, contextEnd); + var pointer = ' ' + new Array(from - contextStart + 1).join(' ') + '^'; + + throw SyntaxError(message + ' at position ' + from + (details ? ': ' + details : '') + '\n' + context + '\n' + pointer); + } + + var backrefDenied = []; + var closedCaptureCounter = 0; + var firstIteration = true; + var shouldReparse = false; + var hasUnicodeFlag = (flags || "").indexOf("u") !== -1; + var hasUnicodeSetFlag = (flags || "").indexOf("v") !== -1; + var isUnicodeMode = hasUnicodeFlag || hasUnicodeSetFlag; + var pos = 0; + + if (hasUnicodeSetFlag && !features.unicodeSet) { + throw new Error('The "v" flag is only supported when the .unicodeSet option is enabled.'); + } + + if (hasUnicodeFlag && hasUnicodeSetFlag) { + throw new Error('The "u" and "v" flags are mutually exclusive.'); + } + + // Convert the input to a string and treat the empty string special. + str = String(str); + if (str === '') { + str = '(?:)'; + } + + var result = parseDisjunction(); + + if (result.range[1] !== str.length) { + bail('Could not parse entire input - got stuck', '', result.range[1]); + } + + // The spec requires to interpret the `\2` in `/\2()()/` as backreference. + // As the parser collects the number of capture groups as the string is + // parsed it is impossible to make these decisions at the point when the + // `\2` is handled. In case the local decision turns out to be wrong after + // the parsing has finished, the input string is parsed a second time with + // the total number of capture groups set. + // + // SEE: https://github.com/jviereck/regjsparser/issues/70 + shouldReparse = shouldReparse || backrefDenied.some(function (ref) { + return ref <= closedCaptureCounter; + }); + if (shouldReparse) { + // Parse the input a second time. + pos = 0; + firstIteration = false; + return parseDisjunction(); + } + + return result; + } + + var regjsparser = { + parse: parse + }; + + if (typeof module !== 'undefined' && module.exports) { + module.exports = regjsparser; + } else { + window.regjsparser = regjsparser; + } + +}()); diff --git a/tools/ui/node_modules/rehype-highlight/index.d.ts b/tools/ui/node_modules/rehype-highlight/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..95af0aba91f54b5e90996b7dbc5b8f7b7eef4531 --- /dev/null +++ b/tools/ui/node_modules/rehype-highlight/index.d.ts @@ -0,0 +1,3 @@ +export { default } from "./lib/index.js"; +export type Options = import("./lib/index.js").Options; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/rehype-highlight/index.d.ts.map b/tools/ui/node_modules/rehype-highlight/index.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..43cfb3e485027272ce4acbecfe05234a90659d31 --- /dev/null +++ b/tools/ui/node_modules/rehype-highlight/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":";sBACa,OAAO,gBAAgB,EAAE,OAAO"} \ No newline at end of file diff --git a/tools/ui/node_modules/rehype-highlight/index.js b/tools/ui/node_modules/rehype-highlight/index.js new file mode 100644 index 0000000000000000000000000000000000000000..a49a278876feae34fbbafdc4ba522fd38143e99b --- /dev/null +++ b/tools/ui/node_modules/rehype-highlight/index.js @@ -0,0 +1,5 @@ +/** + * @typedef {import('./lib/index.js').Options} Options + */ + +export {default} from './lib/index.js' diff --git a/tools/ui/node_modules/rehype-highlight/lib/index.d.ts b/tools/ui/node_modules/rehype-highlight/lib/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..59d74683e230c95a2b2c76f729c6161578b10de4 --- /dev/null +++ b/tools/ui/node_modules/rehype-highlight/lib/index.d.ts @@ -0,0 +1,47 @@ +/** + * Apply syntax highlighting. + * + * @param {Readonly | null | undefined} [options] + * Configuration (optional). + * @returns + * Transform. + */ +export default function rehypeHighlight(options?: Readonly | null | undefined): (tree: Root, file: VFile) => undefined; +/** + * Configuration (optional). + */ +export type Options = { + /** + * Register more aliases (optional); + * passed to `lowlight.registerAlias`. + */ + aliases?: Readonly | string>> | null | undefined; + /** + * Highlight code without language classes by guessing its programming + * language (default: `false`). + */ + detect?: boolean | null | undefined; + /** + * Register languages (default: `common`); + * passed to `lowlight.register`. + */ + languages?: Readonly> | null | undefined; + /** + * List of language names to not highlight (optional); + * note you can also add `no-highlight` classes. + */ + plainText?: ReadonlyArray | null | undefined; + /** + * Class prefix (default: `'hljs-'`). + */ + prefix?: string | null | undefined; + /** + * Names of languages to check when detecting (default: all registered + * languages). + */ + subset?: ReadonlyArray | null | undefined; +}; +import type { Root } from 'hast'; +import type { VFile } from 'vfile'; +import type { LanguageFn } from 'lowlight'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/rehype-highlight/lib/index.d.ts.map b/tools/ui/node_modules/rehype-highlight/lib/index.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..afc3b093ccfae76e86115be3b2db92726b549142 --- /dev/null +++ b/tools/ui/node_modules/rehype-highlight/lib/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAmCA;;;;;;;GAOG;AACH,kDALW,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,UA6BlC,IAAI,QAEJ,KAAK,KAEH,SAAS,CAuEvB;;;;;;;;;cArIa,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS;;;;;aAG3E,OAAO,GAAG,IAAI,GAAG,SAAS;;;;;gBAG1B,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS;;;;;gBAGvD,aAAa,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS;;;;aAGxC,MAAM,GAAG,IAAI,GAAG,SAAS;;;;;aAEzB,aAAa,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS;;0BAtBN,MAAM;2BAE9B,OAAO;gCADF,UAAU"} \ No newline at end of file diff --git a/tools/ui/node_modules/rehype-highlight/lib/index.js b/tools/ui/node_modules/rehype-highlight/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..332a7335e3054f5ca519306aafe8cc124cbb8f2e --- /dev/null +++ b/tools/ui/node_modules/rehype-highlight/lib/index.js @@ -0,0 +1,182 @@ +/** + * @import {ElementContent, Element, Root} from 'hast' + * @import {LanguageFn} from 'lowlight' + * @import {VFile} from 'vfile' + */ + +/** + * @typedef Options + * Configuration (optional). + * @property {Readonly | string>> | null | undefined} [aliases={}] + * Register more aliases (optional); + * passed to `lowlight.registerAlias`. + * @property {boolean | null | undefined} [detect=false] + * Highlight code without language classes by guessing its programming + * language (default: `false`). + * @property {Readonly> | null | undefined} [languages] + * Register languages (default: `common`); + * passed to `lowlight.register`. + * @property {ReadonlyArray | null | undefined} [plainText=[]] + * List of language names to not highlight (optional); + * note you can also add `no-highlight` classes. + * @property {string | null | undefined} [prefix='hljs-'] + * Class prefix (default: `'hljs-'`). + * @property {ReadonlyArray | null | undefined} [subset] + * Names of languages to check when detecting (default: all registered + * languages). + */ + +import {toText} from 'hast-util-to-text' +import {common, createLowlight} from 'lowlight' +import {visit} from 'unist-util-visit' + +/** @type {Options} */ +const emptyOptions = {} + +/** + * Apply syntax highlighting. + * + * @param {Readonly | null | undefined} [options] + * Configuration (optional). + * @returns + * Transform. + */ +export default function rehypeHighlight(options) { + const settings = options || emptyOptions + const aliases = settings.aliases + const detect = settings.detect || false + const languages = settings.languages || common + const plainText = settings.plainText + const prefix = settings.prefix + const subset = settings.subset + let name = 'hljs' + + const lowlight = createLowlight(languages) + + if (aliases) { + lowlight.registerAlias(aliases) + } + + if (prefix) { + const pos = prefix.indexOf('-') + name = pos === -1 ? prefix : prefix.slice(0, pos) + } + + /** + * Transform. + * + * @param {Root} tree + * Tree. + * @param {VFile} file + * File. + * @returns {undefined} + * Nothing. + */ + return function (tree, file) { + visit(tree, 'element', function (node, _, parent) { + if ( + node.tagName !== 'code' || + !parent || + parent.type !== 'element' || + parent.tagName !== 'pre' + ) { + return + } + + const lang = language(node) + + if ( + lang === false || + (!lang && !detect) || + (lang && plainText && plainText.includes(lang)) + ) { + return + } + + if (!Array.isArray(node.properties.className)) { + node.properties.className = [] + } + + if (!node.properties.className.includes(name)) { + node.properties.className.unshift(name) + } + + const text = toText(node, {whitespace: 'pre'}) + /** @type {Root} */ + let result + + try { + result = lang + ? lowlight.highlight(lang, text, {prefix}) + : lowlight.highlightAuto(text, {prefix, subset}) + } catch (error) { + const cause = /** @type {Error} */ (error) + + if (lang && /Unknown language/.test(cause.message)) { + file.message( + 'Cannot highlight as `' + lang + '`, it’s not registered', + { + ancestors: [parent, node], + cause, + place: node.position, + ruleId: 'missing-language', + source: 'rehype-highlight' + } + ) + + /* c8 ignore next 5 -- throw arbitrary hljs errors */ + return + } + + throw cause + } + + if (!lang && result.data && result.data.language) { + node.properties.className.push('language-' + result.data.language) + } + + if (result.children.length > 0) { + node.children = /** @type {Array} */ (result.children) + } + }) + } +} + +/** + * Get the programming language of `node`. + * + * @param {Element} node + * Node. + * @returns {false | string | undefined} + * Language or `undefined`, or `false` when an explikcit `no-highlight` class + * is used. + */ +function language(node) { + const list = node.properties.className + let index = -1 + + if (!Array.isArray(list)) { + return + } + + /** @type {string | undefined} */ + let name + + while (++index < list.length) { + const value = String(list[index]) + + if (value === 'no-highlight' || value === 'nohighlight') { + return false + } + + if (!name && value.slice(0, 5) === 'lang-') { + name = value.slice(5) + } + + if (!name && value.slice(0, 9) === 'language-') { + name = value.slice(9) + } + } + + return name +} diff --git a/tools/ui/node_modules/rehype-highlight/license b/tools/ui/node_modules/rehype-highlight/license new file mode 100644 index 0000000000000000000000000000000000000000..bc8f165a62768a19de38901d81ac662c51ff29db --- /dev/null +++ b/tools/ui/node_modules/rehype-highlight/license @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) Titus Wormer + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/rehype-highlight/package.json b/tools/ui/node_modules/rehype-highlight/package.json new file mode 100644 index 0000000000000000000000000000000000000000..de39131eae88b0bfa29f26ee6e4bb36ada5c462a --- /dev/null +++ b/tools/ui/node_modules/rehype-highlight/package.json @@ -0,0 +1,86 @@ +{ + "author": "Titus Wormer (https://wooorm.com)", + "bugs": "https://github.com/rehypejs/rehype-highlight/issues", + "contributors": [ + "Titus Wormer (https://wooorm.com)" + ], + "dependencies": { + "@types/hast": "^3.0.0", + "hast-util-to-text": "^4.0.0", + "lowlight": "^3.0.0", + "unist-util-visit": "^5.0.0", + "vfile": "^6.0.0" + }, + "description": "rehype plugin to highlight code blocks with lowlight (highlight.js)", + "devDependencies": { + "@types/node": "^22.0.0", + "c8": "^10.0.0", + "prettier": "^3.0.0", + "rehype-parse": "^9.0.0", + "rehype-stringify": "^10.0.0", + "remark-cli": "^12.0.0", + "remark-preset-wooorm": "^11.0.0", + "type-coverage": "^2.0.0", + "typescript": "^5.0.0", + "unified": "^11.0.0", + "xo": "^0.60.0" + }, + "exports": "./index.js", + "files": [ + "index.d.ts.map", + "index.d.ts", + "index.js", + "lib/" + ], + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + }, + "keywords": [ + "hast", + "highlighting", + "highlight", + "html", + "plugin", + "rehype-plugin", + "rehype", + "syntax", + "unified" + ], + "license": "MIT", + "name": "rehype-highlight", + "prettier": { + "bracketSpacing": false, + "singleQuote": true, + "semi": false, + "tabWidth": 2, + "trailingComma": "none", + "useTabs": false + }, + "remarkConfig": { + "plugins": [ + "remark-preset-wooorm" + ] + }, + "repository": "rehypejs/rehype-highlight", + "scripts": { + "build": "tsc --build --clean && tsc --build && type-coverage", + "format": "remark --frail --output --quiet -- . && prettier --log-level warn --write -- . && xo --fix", + "test-api": "node --conditions development test.js", + "test-coverage": "c8 --100 --reporter lcov -- npm run test-api", + "test": "npm run build && npm run format && npm run test-coverage" + }, + "sideEffects": false, + "typeCoverage": { + "atLeast": 100, + "strict": true + }, + "type": "module", + "version": "7.0.2", + "xo": { + "prettier": true, + "rules": { + "complexity": "off" + } + } +} diff --git a/tools/ui/node_modules/rehype-highlight/readme.md b/tools/ui/node_modules/rehype-highlight/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..56ed9f1451ce0117bf7b5d9b7e2f4acdf0c9e3e1 --- /dev/null +++ b/tools/ui/node_modules/rehype-highlight/readme.md @@ -0,0 +1,533 @@ +# rehype-highlight + +[![Build][build-badge]][build] +[![Coverage][coverage-badge]][coverage] +[![Downloads][downloads-badge]][downloads] +[![Size][size-badge]][size] +[![Sponsors][sponsors-badge]][collective] +[![Backers][backers-badge]][collective] +[![Chat][chat-badge]][chat] + +**[rehype][]** plugin to apply syntax highlighting to code with +[`lowlight`][lowlight]. + +## Contents + +* [What is this?](#what-is-this) +* [When should I use this?](#when-should-i-use-this) +* [Install](#install) +* [Use](#use) +* [API](#api) + * [`unified().use(rehypeHighlight[, options])`](#unifieduserehypehighlight-options) + * [`Options`](#options) +* [Example](#example) + * [Example: ignoring](#example-ignoring) + * [Example: registering](#example-registering) + * [Example: aliases](#example-aliases) + * [Example: sanitation](#example-sanitation) + * [Example: line numbering and highlighting](#example-line-numbering-and-highlighting) +* [Types](#types) +* [HTML](#html) +* [CSS](#css) +* [Compatibility](#compatibility) +* [Security](#security) +* [Related](#related) +* [Contribute](#contribute) +* [License](#license) + +## What is this? + +This package is a [unified][] ([rehype][]) plugin to perform syntax +highlighting. +It uses `highlight.js` through `lowlight`, which is pretty fast, relatively +small, and quite good. +This package bundles 37 [common languages][lowlight-common] by default and you +can register more (190 with [`all`][lowlight-all]). + +It looks for `` elements (when directly in `
` elements) and changes
+them.
+You can specify the code language (such as Python) with a `language-*` or
+`lang-*` class, where the `*` can be for example `js` (so `language-js`), `md`,
+`css`, etc.
+By default, code without such a language class is not highlighted.
+Pass `detect: true` to detect their programming language and highlight the code
+anyway.
+You can prevent specific blocks from being highlighted with a `no-highlight` or
+`nohighlight` class on the ``.
+
+**unified** is a project that transforms content with abstract syntax trees
+(ASTs).
+**rehype** adds support for HTML to unified.
+**hast** is the HTML AST that rehype uses.
+This is a rehype plugin that applies syntax highlighting to the AST.
+
+## When should I use this?
+
+This project is useful when you want to perform syntax highlighting in rehype.
+One reason to do that is that it typically means the highlighting happens once
+at build time instead of every time at run time.
+
+When you want a high quality highlighter that can support tons of grammars and
+approaches how GitHub renders code,
+you can use [`rehype-starry-night`][rehype-starry-night].
+
+This plugin is built on [`lowlight`][lowlight], which is a virtual version of
+highlight.js.
+You can make a plugin based on this one with lowlight when you want to do things
+differently.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install rehype-highlight
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import rehypeHighlight from 'https://esm.sh/rehype-highlight@6'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+
+```
+
+## Use
+
+Say we have the following file `example.html`:
+
+```html
+
Hello World!

+
+
var name = "World";
+console.warn("Hello, " + name + "!")

+```
+
+…and our module `example.js` contains:
+
+```js
+import rehypeHighlight from 'rehype-highlight'
+import rehypeParse from 'rehype-parse'
+import rehypeStringify from 'rehype-stringify'
+import {read} from 'to-vfile'
+import {unified} from 'unified'
+
+const file = await read('example.html')
+
+await unified()
+  .use(rehypeParse, {fragment: true})
+  .use(rehypeHighlight)
+  .use(rehypeStringify)
+  .process(file)
+
+console.log(String(file))
+```
+
+…then running `node example.js` yields:
+
+```html
+
Hello World!

+
+
var name = "World";
+console.warn("Hello, " + name + "!")

+```
+
+## API
+
+This package exports no identifiers.
+The default export is [`rehypeHighlight`][api-rehype-highlight].
+
+### `unified().use(rehypeHighlight[, options])`
+
+Apply syntax highlighting.
+
+###### Parameters
+
+* `options` ([`Options`][api-options], optional)
+  — configuration
+
+###### Returns
+
+Transform ([`Transformer`][unified-transformer]).
+
+### `Options`
+
+Configuration (TypeScript type).
+
+###### Fields
+
+* `aliases` (`Record | string>`, optional)
+  — register more aliases;
+  passed to [`lowlight.registerAlias`][lowlight-register-alias]
+* `detect` (`boolean`, default: `false`)
+  — highlight code without language classes by guessing its programming
+  language
+* `languages` (`Record`, default:
+  [`common`][lowlight-common])
+  — register languages; passed to [`lowlight.register`][lowlight-register]
+* `plainText` (`Array`, optional)
+  — list of language names to not highlight;
+  note you can also add `no-highlight` classes
+* `prefix` (`string`, default: `'hljs-'`)
+  — class prefix
+* `subset` (`Array`, default: default: [all][lowlight-all] registered
+  languages)
+  — names of languages to check when detecting
+
+## Example
+
+### Example: ignoring
+
+There are three ways to not apply syntax highlighting to code blocks.
+They can be ignored with an explicit class of `no-highlight` (or `nohighlight`),
+an explicit language name that’s listed in `options.plainText`, or by setting
+`options.detect` to `false` (default), which prevents `` without a class
+from being automatically detected.
+
+For example, with `example.html`:
+
+```html
+
this won’t be highlighted due to `detect: false` (default)

+
+
this won’t be highlighted due to its class

+
+
this won’t be highlighted due to `plainText: ['txt']`

+```
+
+…and `example.js`:
+
+```js
+import {rehype} from 'rehype'
+import rehypeHighlight from 'rehype-highlight'
+import {read} from 'to-vfile'
+
+const file = await rehype()
+  .data('settings', {fragment: true})
+  .use(rehypeHighlight, {plainText: ['txt', 'text']})
+  .process(await read('example.html'))
+
+console.log(String(file))
+```
+
+…then running that yields the same as `example.html`: none of them are
+highlighted.
+
+### Example: registering
+
+`rehype-highlight` supports 37 commonly used languages by default.
+This makes it small to load in browsers and Node.js, while supporting enough
+default cases.
+You can add more languages.
+
+For example, with `example.html`:
+
+```html
+
a ::= 'a' | 'A'

+```
+
+…and `example.js`:
+
+```js
+import bnf from 'highlight.js/lib/languages/bnf'
+import {common} from 'lowlight'
+import {rehype} from 'rehype'
+import rehypeHighlight from 'rehype-highlight'
+import {read} from 'to-vfile'
+
+const file = await rehype()
+  .data('settings', {fragment: true})
+  .use(rehypeHighlight, {languages: {...common, bnf}})
+  .process(await read('example.html'))
+
+console.log(String(file))
+```
+
+…then running that yields:
+
+```html
+
a ::= 'a' | 'A'

+```
+
+### Example: aliases
+
+You can map your own language flags to `highlight.js` languages.
+
+For example, with `example.html`:
+
+```html
+
console.log(1)

+```
+
+…and `example.js`:
+
+```js
+import {rehype} from 'rehype'
+import rehypeHighlight from 'rehype-highlight'
+import {read} from 'to-vfile'
+
+const file = await rehype()
+  .data('settings', {fragment: true})
+  // 👉 **Note**: the keys are language names, values are the aliases that you
+  // want to also allow as `x` in `language-x` classes.
+  .use(rehypeHighlight, {aliases: {'javascript': 'custom-script'}})
+  .process(await read('example.html'))
+
+console.log(String(file))
+```
+
+…then running that yields:
+
+```html
+
console.log(1)

+```
+
+### Example: sanitation
+
+Applying syntax highlighting in rehype operates on `` elements with
+certain classes and it injects many `` elements with classes.
+Allowing arbitrary classes is an opening for security vulnerabilities.
+
+To make HTML safe in rehype, use [`rehype-sanitize`][rehype-sanitize].
+It specifically allows `/^language-./` class names on `` elements.
+Which we also use.
+So you can use `rehype-highlight` after `rehype-sanitize`:
+
+```js
+import {unified} from 'unified'
+import rehypeHighlight from './index.js'
+import rehypeParse from 'rehype-parse'
+import rehypeSanitize, {defaultSchema} from 'rehype-sanitize'
+import rehypeStringify from 'rehype-stringify'
+
+const file = await unified()
+  .use(rehypeParse, {fragment: true})
+  .use(rehypeSanitize)
+  .use(rehypeHighlight)
+  .use(rehypeStringify)
+  .process('
console.log(1)
')
+
+console.log(String(file))
+```
+
+…yields:
+
+```html
+
console.log(1)

+```
+
+Using plugins *after* `rehype-sanitize`, like we just did, is *safe* assuming
+you trust those plugins.
+If you do not trust `rehype-highlight`, you can use it before.
+But then you need to configure `rehype-sanitize` to keep the classes you allow:
+
+```js
+import {unified} from 'unified'
+import rehypeHighlight from './index.js'
+import rehypeParse from 'rehype-parse'
+import rehypeSanitize, {defaultSchema} from 'rehype-sanitize'
+import rehypeStringify from 'rehype-stringify'
+
+const file = await unified()
+  .use(rehypeParse, {fragment: true})
+  .use(rehypeHighlight)
+  .use(rehypeSanitize, {
+    ...defaultSchema,
+    attributes: {
+      ...defaultSchema.attributes,
+      span: [
+        ...(defaultSchema.attributes?.span || []),
+        // Allow all class names starting with `hljs-`.
+        ['className', /^hljs-./]
+        // Alternatively, to allow only certain class names:
+        // ['className', 'hljs-number', 'hljs-title', 'hljs-variable']
+      ]
+    },
+    tagNames: [...(defaultSchema.tagNames || []), 'span']
+  })
+  .use(rehypeStringify)
+  .process('
console.log(1)
')
+
+console.log(String(file))
+```
+
+### Example: line numbering and highlighting
+
+You can add support for line numbers and line highlighting with a separate
+plugin, [`rehype-highlight-code-lines`][rehype-highlight-code-lines].
+
+For example, with `example.html`:
+
+```html
+
console.log("Hi!")

+```
+
+…and `example.js`:
+
+```js
+import {rehype} from 'rehype'
+import rehypeHighlight from 'rehype-highlight'
+import rehypeHighlightCodeLines from 'rehype-highlight-code-lines'
+import {read} from 'to-vfile'
+
+const file = await rehype()
+  .data('settings', {fragment: true})
+  .use(rehypeHighlight)
+  .use(rehypeHighlightCodeLines, {
+    showLineNumbers: true,
+    lineContainerTagName: 'div'
+  })
+  .process(await read('example.html'))
+
+console.log(String(file))
+```
+
+…then running that yields:
+
+```html
+
console.log("Hi!")

+```
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional type [`Options`][api-options].
+
+## HTML
+
+On the input side,
+this plugin looks for code blocks with a `language-*` class.
+
+On the output side,
+this plugin generates `span` elements with classes that can be enhanced with
+CSS.
+
+## CSS
+
+See [“CSS” in `lowlight`][github-lowlight-css] for more info.
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line, `rehype-highlight@^7`,
+compatible with Node.js 16.
+
+This plugin works with `rehype-parse` version 1+, `rehype-stringify` version 1+,
+`rehype` version 1+, and `unified` version 4+.
+
+## Security
+
+Use of `rehype-highlight` *should* be safe to use as `highlight.js` and
+`lowlight` *should* be safe to use.
+When in doubt, use [`rehype-sanitize`][rehype-sanitize].
+
+## Related
+
+* [`rehype-starry-night`][rehype-starry-night]
+  — apply syntax highlighting with `starry-night`
+* [`rehype-meta`](https://github.com/rehypejs/rehype-meta)
+  — add metadata to the head of a document
+* [`rehype-document`](https://github.com/rehypejs/rehype-document)
+  — wrap a fragment in a document
+* [`rehype-highlight-code-lines`][rehype-highlight-code-lines]
+  — add line numbers and highlight lines
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`rehypejs/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+
+
+[api-options]: #options
+
+[api-rehype-highlight]: #unifieduserehypehighlight-options
+
+[author]: https://wooorm.com
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[build]: https://github.com/rehypejs/rehype-highlight/actions
+
+[build-badge]: https://github.com/rehypejs/rehype-highlight/workflows/main/badge.svg
+
+[chat]: https://github.com/rehypejs/rehype/discussions
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[coc]: https://github.com/rehypejs/.github/blob/HEAD/code-of-conduct.md
+
+[collective]: https://opencollective.com/unified
+
+[contributing]: https://github.com/rehypejs/.github/blob/HEAD/contributing.md
+
+[coverage]: https://codecov.io/github/rehypejs/rehype-highlight
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/rehypejs/rehype-highlight.svg
+
+[downloads]: https://www.npmjs.com/package/rehype-highlight
+
+[downloads-badge]: https://img.shields.io/npm/dm/rehype-highlight.svg
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[github-lowlight-css]: https://github.com/wooorm/lowlight#css
+
+[health]: https://github.com/rehypejs/.github
+
+[license]: license
+
+[lowlight]: https://github.com/wooorm/lowlight
+
+[lowlight-all]: https://github.com/wooorm/lowlight#all
+
+[lowlight-common]: https://github.com/wooorm/lowlight#common
+
+[lowlight-register]: https://github.com/wooorm/lowlight#lowlightregistergrammars
+
+[lowlight-register-alias]: https://github.com/wooorm/lowlight#lowlightregisteraliasaliases
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[rehype]: https://github.com/rehypejs/rehype
+
+[rehype-highlight-code-lines]: https://github.com/ipikuka/rehype-highlight-code-lines
+
+[rehype-sanitize]: https://github.com/rehypejs/rehype-sanitize
+
+[rehype-starry-night]: https://github.com/rehypejs/rehype-starry-night
+
+[size]: https://bundlejs.com/?q=rehype-highlight
+
+[size-badge]: https://img.shields.io/bundlejs/size/rehype-highlight
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[support]: https://github.com/rehypejs/.github/blob/HEAD/support.md
+
+[typescript]: https://www.typescriptlang.org
+
+[unified]: https://github.com/unifiedjs/unified
+
+[unified-transformer]: https://github.com/unifiedjs/unified#transformer
diff --git a/tools/ui/node_modules/rehype-katex/index.d.ts b/tools/ui/node_modules/rehype-katex/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..95af0aba91f54b5e90996b7dbc5b8f7b7eef4531
--- /dev/null
+++ b/tools/ui/node_modules/rehype-katex/index.d.ts
@@ -0,0 +1,3 @@
+export { default } from "./lib/index.js";
+export type Options = import("./lib/index.js").Options;
+//# sourceMappingURL=index.d.ts.map
\ No newline at end of file
diff --git a/tools/ui/node_modules/rehype-katex/index.d.ts.map b/tools/ui/node_modules/rehype-katex/index.d.ts.map
new file mode 100644
index 0000000000000000000000000000000000000000..43cfb3e485027272ce4acbecfe05234a90659d31
--- /dev/null
+++ b/tools/ui/node_modules/rehype-katex/index.d.ts.map
@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":";sBACa,OAAO,gBAAgB,EAAE,OAAO"}
\ No newline at end of file
diff --git a/tools/ui/node_modules/rehype-katex/index.js b/tools/ui/node_modules/rehype-katex/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..a49a278876feae34fbbafdc4ba522fd38143e99b
--- /dev/null
+++ b/tools/ui/node_modules/rehype-katex/index.js
@@ -0,0 +1,5 @@
+/**
+ * @typedef {import('./lib/index.js').Options} Options
+ */
+
+export {default} from './lib/index.js'
diff --git a/tools/ui/node_modules/rehype-katex/lib/index.d.ts b/tools/ui/node_modules/rehype-katex/lib/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7a646b1e459b25a1959f21e88b6be4fed638d8ca
--- /dev/null
+++ b/tools/ui/node_modules/rehype-katex/lib/index.d.ts
@@ -0,0 +1,15 @@
+/**
+ * Render elements with a `language-math` (or `math-display`, `math-inline`)
+ * class with KaTeX.
+ *
+ * @param {Readonly | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns
+ *   Transform.
+ */
+export default function rehypeKatex(options?: Readonly | null | undefined): (tree: Root, file: VFile) => undefined;
+export type Options = Omit;
+import type { Root } from 'hast';
+import type { VFile } from 'vfile';
+import katex from 'katex';
+//# sourceMappingURL=index.d.ts.map
\ No newline at end of file
diff --git a/tools/ui/node_modules/rehype-katex/lib/index.d.ts.map b/tools/ui/node_modules/rehype-katex/lib/index.d.ts.map
new file mode 100644
index 0000000000000000000000000000000000000000..4316f4da004f5dfd069307b1bea0c10864790cb9
--- /dev/null
+++ b/tools/ui/node_modules/rehype-katex/lib/index.d.ts.map
@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAoBA;;;;;;;;GAQG;AACH,8CALW,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,UAWlC,IAAI,QAEJ,KAAK,KAEH,SAAS,CAuGvB;sBAvIY,IAAI,CAAC,kBAAY,EAAE,aAAa,GAAG,cAAc,CAAC;0BANxB,MAAM;2BAErB,OAAO;kBASb,OAAO"}
\ No newline at end of file
diff --git a/tools/ui/node_modules/rehype-katex/lib/index.js b/tools/ui/node_modules/rehype-katex/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f858c8e64ffa2b28b3acba23bf1d206f7596624
--- /dev/null
+++ b/tools/ui/node_modules/rehype-katex/lib/index.js
@@ -0,0 +1,143 @@
+/**
+ * @import {ElementContent, Root} from 'hast'
+ * @import {KatexOptions} from 'katex'
+ * @import {VFile} from 'vfile'
+ */
+
+/**
+ * @typedef {Omit} Options
+ */
+
+import {fromHtmlIsomorphic} from 'hast-util-from-html-isomorphic'
+import {toText} from 'hast-util-to-text'
+import katex from 'katex'
+import {SKIP, visitParents} from 'unist-util-visit-parents'
+
+/** @type {Readonly} */
+const emptyOptions = {}
+/** @type {ReadonlyArray} */
+const emptyClasses = []
+
+/**
+ * Render elements with a `language-math` (or `math-display`, `math-inline`)
+ * class with KaTeX.
+ *
+ * @param {Readonly | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns
+ *   Transform.
+ */
+export default function rehypeKatex(options) {
+  const settings = options || emptyOptions
+
+  /**
+   * Transform.
+   *
+   * @param {Root} tree
+   *   Tree.
+   * @param {VFile} file
+   *   File.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  return function (tree, file) {
+    visitParents(tree, 'element', function (element, parents) {
+      const classes = Array.isArray(element.properties.className)
+        ? element.properties.className
+        : emptyClasses
+      // This class can be generated from markdown with ` ```math `.
+      const languageMath = classes.includes('language-math')
+      // This class is used by `remark-math` for flow math (block, `$$\nmath\n$$`).
+      const mathDisplay = classes.includes('math-display')
+      // This class is used by `remark-math` for text math (inline, `$math$`).
+      const mathInline = classes.includes('math-inline')
+      let displayMode = mathDisplay
+
+      // Any class is fine.
+      if (!languageMath && !mathDisplay && !mathInline) {
+        return
+      }
+
+      let parent = parents[parents.length - 1]
+      let scope = element
+
+      // If this was generated with ` ```math `, replace the `
` and use
+      // display.
+      if (
+        element.tagName === 'code' &&
+        languageMath &&
+        parent &&
+        parent.type === 'element' &&
+        parent.tagName === 'pre'
+      ) {
+        scope = parent
+        parent = parents[parents.length - 2]
+        displayMode = true
+      }
+
+      /* c8 ignore next -- verbose to test. */
+      if (!parent) return
+
+      const value = toText(scope, {whitespace: 'pre'})
+
+      /** @type {Array | string | undefined} */
+      let result
+
+      try {
+        result = katex.renderToString(value, {
+          ...settings,
+          displayMode,
+          throwOnError: true
+        })
+      } catch (error) {
+        const cause = /** @type {Error} */ (error)
+        const ruleId = cause.name.toLowerCase()
+
+        file.message('Could not render math with KaTeX', {
+          ancestors: [...parents, element],
+          cause,
+          place: element.position,
+          ruleId,
+          source: 'rehype-katex'
+        })
+
+        // KaTeX *should* handle `ParseError` itself, but not others.
+        // it doesn’t always:
+        // 
+        try {
+          result = katex.renderToString(value, {
+            ...settings,
+            displayMode,
+            strict: 'ignore',
+            throwOnError: false
+          })
+        } catch {
+          // Generate similar markup if this is an other error.
+          // See: .
+          result = [
+            {
+              type: 'element',
+              tagName: 'span',
+              properties: {
+                className: ['katex-error'],
+                style: 'color:' + (settings.errorColor || '#cc0000'),
+                title: String(error)
+              },
+              children: [{type: 'text', value}]
+            }
+          ]
+        }
+      }
+
+      if (typeof result === 'string') {
+        const root = fromHtmlIsomorphic(result, {fragment: true})
+        // Cast as we don’t expect `doctypes` in KaTeX result.
+        result = /** @type {Array} */ (root.children)
+      }
+
+      const index = parent.children.indexOf(scope)
+      parent.children.splice(index, 1, ...result)
+      return SKIP
+    })
+  }
+}
diff --git a/tools/ui/node_modules/rehype-katex/package.json b/tools/ui/node_modules/rehype-katex/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..82d54f83cf765562e4b50d4951a0da19fb8afebe
--- /dev/null
+++ b/tools/ui/node_modules/rehype-katex/package.json
@@ -0,0 +1,60 @@
+{
+  "name": "rehype-katex",
+  "version": "7.0.1",
+  "description": "rehype plugin to transform inline and block math with KaTeX",
+  "license": "MIT",
+  "keywords": [
+    "hast",
+    "html",
+    "katex",
+    "latex",
+    "markdown",
+    "math",
+    "mdast",
+    "plugin",
+    "rehype",
+    "rehype-plugin",
+    "remark",
+    "tex",
+    "unified"
+  ],
+  "repository": "https://github.com/remarkjs/remark-math/tree/main/packages/rehype-katex",
+  "bugs": "https://github.com/remarkjs/remark-math/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Junyoung Choi  (https://rokt33r.github.io)",
+  "contributors": [
+    "Junyoung Choi  (https://rokt33r.github.io)",
+    "Titus Wormer  (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./index.js",
+  "files": [
+    "lib/",
+    "index.d.ts.map",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "@types/hast": "^3.0.0",
+    "@types/katex": "^0.16.0",
+    "hast-util-from-html-isomorphic": "^2.0.0",
+    "hast-util-to-text": "^4.0.0",
+    "katex": "^0.16.0",
+    "unist-util-visit-parents": "^6.0.0",
+    "vfile": "^6.0.0"
+  },
+  "scripts": {
+    "test-api": "node --conditions development test.js",
+    "test": "npm run build && npm run test-api"
+  },
+  "xo": {
+    "prettier": true,
+    "rules": {
+      "unicorn/prefer-at": "off"
+    }
+  }
+}
diff --git a/tools/ui/node_modules/rehype-katex/readme.md b/tools/ui/node_modules/rehype-katex/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..dcef824e120e60718d3c707e6a946941cdb9eadd
--- /dev/null
+++ b/tools/ui/node_modules/rehype-katex/readme.md
@@ -0,0 +1,348 @@
+# rehype-katex
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][sponsors-badge]][collective]
+[![Backers][backers-badge]][collective]
+[![Chat][chat-badge]][chat]
+
+**[rehype][]** plugin to render elements with a `language-math` class with
+[KaTeX][].
+
+## Contents
+
+* [What is this?](#what-is-this)
+* [When should I use this?](#when-should-i-use-this)
+* [Install](#install)
+* [Use](#use)
+* [API](#api)
+  * [`unified().use(rehypeKatex[, options])`](#unifieduserehypekatex-options)
+  * [`Options`](#options)
+* [Markdown](#markdown)
+* [HTML](#html)
+* [CSS](#css)
+* [Types](#types)
+* [Compatibility](#compatibility)
+* [Security](#security)
+* [Related](#related)
+* [Contribute](#contribute)
+* [License](#license)
+
+## What is this?
+
+This package is a [unified][] ([rehype][]) plugin to render math.
+You can add classes to HTML elements, use fenced code in markdown, or combine
+with [`remark-math`][remark-math] for a `$C$` syntax extension.
+
+## When should I use this?
+
+This project is useful as it renders math with KaTeX at compile time, which
+means that there is no client side JavaScript needed.
+
+A different plugin, [`rehype-mathjax`][rehype-mathjax], does the same but with
+[MathJax][].
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install rehype-katex
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import rehypeKatex from 'https://esm.sh/rehype-katex@7'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+
+```
+
+## Use
+
+Say our document `input.html` contains:
+
+```html
+

+  Lift(L) can be determined by Lift Coefficient
+  (C_L) like the following equation.
+

+

+  L = \frac{1}{2} \rho v^2 S C_L
+

+```
+
+…and our module `example.js` contains:
+
+```js
+import rehypeDocument from 'rehype-document'
+import rehypeKatex from 'rehype-katex'
+import rehypeParse from 'rehype-parse'
+import rehypeStringify from 'rehype-stringify'
+import {read, write} from 'to-vfile'
+import {unified} from 'unified'
+
+const file = await unified()
+  .use(rehypeParse, {fragment: true})
+  .use(rehypeDocument, {
+    // Get the latest one from: .
+    css: 'https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.css'
+  })
+  .use(rehypeKatex)
+  .use(rehypeStringify)
+  .process(await read('input.html'))
+
+file.basename = 'output.html'
+await write(file)
+```
+
+…then running `node example.js` creates an `output.html` with:
+
+```html
+
+
+
+
+input
+
+
+
+
+

+  Lift() can be determined by Lift Coefficient
+  () like the following equation.
+

+
+
+
+```
+
+…open `output.html` in a browser to see the rendered math.
+
+## API
+
+This package exports no identifiers.
+The default export is [`rehypeKatex`][api-rehype-katex].
+
+### `unified().use(rehypeKatex[, options])`
+
+Render elements with a `language-math` (or `math-display`, `math-inline`)
+class with [KaTeX][].
+
+###### Parameters
+
+* `options` ([`Options`][api-options])
+  — configuration
+
+###### Returns
+
+Transform ([`Transformer`][unified-transformer]).
+
+### `Options`
+
+Configuration (TypeScript type).
+
+###### Type
+
+```ts
+import {KatexOptions} from 'katex'
+
+type Options = Omit
+```
+
+See [*Options* on `katex.org`][katex-options] for more info.
+
+## Markdown
+
+This plugin supports the syntax extension enabled by
+[`remark-math`][remark-math].
+It also supports math generated by using fenced code:
+
+````markdown
+```math
+C_L
+```
+````
+
+## HTML
+
+The content of any element with a `language-math`, `math-inline`, or
+`math-display` class is transformed.
+The elements are replaced by what KaTeX renders.
+Either a `math-display` class or using `
` will
+result in “display” math: math that is a centered block on its own line.
+
+## CSS
+
+The HTML produced by KaTeX requires CSS to render correctly.
+You should use `katex.css` somewhere on the page where the math is shown to
+style it properly.
+At the time of writing, the last version is:
+
+```html
+
+
+```
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional type [`Options`][api-options].
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line, `rehype-katex@^7`,
+compatible with Node.js 16.
+
+This plugin works with unified version 6+ and rehype version 4+.
+
+## Security
+
+Assuming you trust KaTeX, using `rehype-katex` is safe.
+A vulnerability in it could open you to a
+[cross-site scripting (XSS)][wiki-xss] attack.
+Be wary of user input and use [`rehype-sanitize`][rehype-sanitize].
+
+When you don’t trust user content but do trust KaTeX, run `rehype-katex`
+*after* `rehype-sanitize`:
+
+```js
+import rehypeKatex from 'rehype-katex'
+import rehypeSanitize, {defaultSchema} from 'rehype-sanitize'
+import rehypeStringify from 'rehype-stringify'
+import remarkMath from 'remark-math'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import {unified} from 'unified'
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkMath)
+  .use(remarkRehype)
+  .use(rehypeSanitize, {
+    ...defaultSchema,
+    attributes: {
+      ...defaultSchema.attributes,
+      // The `language-*` regex is allowed by default.
+      code: [['className', /^language-./, 'math-inline', 'math-display']]
+    }
+  })
+  .use(rehypeKatex)
+  .use(rehypeStringify)
+  .process('$C$')
+
+console.log(String(file))
+```
+
+## Related
+
+* [`rehype-mathjax`][rehype-mathjax]
+  — same but with MathJax
+* [`rehype-highlight`](https://github.com/rehypejs/rehype-highlight)
+  — highlight code blocks
+* [`rehype-autolink-headings`](https://github.com/rehypejs/rehype-autolink-headings)
+  — add links to headings
+* [`rehype-sanitize`](https://github.com/rehypejs/rehype-sanitize)
+  — sanitize HTML
+* [`rehype-document`](https://github.com/rehypejs/rehype-document)
+  — wrap a document around the tree
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`remarkjs/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Junyoung Choi][author]
+
+
+
+[build-badge]: https://github.com/remarkjs/remark-math/workflows/main/badge.svg
+
+[build]: https://github.com/remarkjs/remark-math/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/remarkjs/remark-math.svg
+
+[coverage]: https://codecov.io/github/remarkjs/remark-math
+
+[downloads-badge]: https://img.shields.io/npm/dm/rehype-katex.svg
+
+[downloads]: https://www.npmjs.com/package/rehype-katex
+
+[size-badge]: https://img.shields.io/bundlejs/size/rehype-katex
+
+[size]: https://bundlejs.com/?q=rehype-katex
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[collective]: https://opencollective.com/unified
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/remarkjs/remark/discussions
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[health]: https://github.com/remarkjs/.github
+
+[contributing]: https://github.com/remarkjs/.github/blob/main/contributing.md
+
+[support]: https://github.com/remarkjs/.github/blob/main/support.md
+
+[coc]: https://github.com/remarkjs/.github/blob/main/code-of-conduct.md
+
+[license]: https://github.com/remarkjs/remark-math/blob/main/license
+
+[author]: https://rokt33r.github.io
+
+[katex]: https://github.com/Khan/KaTeX
+
+[katex-options]: https://katex.org/docs/options.html
+
+[rehype]: https://github.com/rehypejs/rehype
+
+[rehype-sanitize]: https://github.com/rehypejs/rehype-sanitize
+
+[unified]: https://github.com/unifiedjs/unified
+
+[unified-transformer]: https://github.com/unifiedjs/unified#transformer
+
+[typescript]: https://www.typescriptlang.org
+
+[wiki-xss]: https://en.wikipedia.org/wiki/Cross-site_scripting
+
+[mathjax]: https://www.mathjax.org
+
+[remark-math]: ../remark-math/
+
+[rehype-mathjax]: ../rehype-mathjax/
+
+[api-options]: #options
+
+[api-rehype-katex]: #unifieduserehypekatex-options
diff --git a/tools/ui/node_modules/rehype-stringify/index.d.ts b/tools/ui/node_modules/rehype-stringify/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3c1b483a041595fd30ef252ba8f7db3210da050e
--- /dev/null
+++ b/tools/ui/node_modules/rehype-stringify/index.d.ts
@@ -0,0 +1,27 @@
+import type {Root} from 'hast'
+import type {Plugin} from 'unified'
+import type {Options} from 'hast-util-to-html'
+
+export type {CharacterReferences, Options} from 'hast-util-to-html'
+
+/**
+ * Plugin to add support for serializing as HTML.
+ *
+ * @this
+ *   Unified processor.
+ * @param
+ *   Configuration (optional).
+ * @returns
+ *   Nothing.
+ */
+declare const rehypeStringify: Plugin<
+  [(Options | null | undefined)?],
+  Root,
+  string
+>
+export default rehypeStringify
+
+// Add custom settings supported when `rehype-stringify` is added.
+declare module 'unified' {
+  interface Settings extends Options {}
+}
diff --git a/tools/ui/node_modules/rehype-stringify/index.js b/tools/ui/node_modules/rehype-stringify/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a4c25d60f746eac9b80f56076fa90be149881a2
--- /dev/null
+++ b/tools/ui/node_modules/rehype-stringify/index.js
@@ -0,0 +1,2 @@
+// Note: types exposed from `index.d.ts`.
+export {default} from './lib/index.js'
diff --git a/tools/ui/node_modules/rehype-stringify/lib/index.d.ts b/tools/ui/node_modules/rehype-stringify/lib/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..02f65516bebab1e497ad5f0a5e93db36fe6210aa
--- /dev/null
+++ b/tools/ui/node_modules/rehype-stringify/lib/index.d.ts
@@ -0,0 +1,24 @@
+/**
+ * Plugin to add support for serializing as HTML.
+ *
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function rehypeStringify(options?: Options | null | undefined): undefined;
+export default class rehypeStringify {
+    /**
+     * Plugin to add support for serializing as HTML.
+     *
+     * @param {Options | null | undefined} [options]
+     *   Configuration (optional).
+     * @returns {undefined}
+     *   Nothing.
+     */
+    constructor(options?: Options | null | undefined);
+    compiler: (tree: Root, file: import("vfile").VFile) => string;
+}
+import type { Options } from 'hast-util-to-html';
+import type { Root } from 'hast';
+//# sourceMappingURL=index.d.ts.map
\ No newline at end of file
diff --git a/tools/ui/node_modules/rehype-stringify/lib/index.d.ts.map b/tools/ui/node_modules/rehype-stringify/lib/index.d.ts.map
new file mode 100644
index 0000000000000000000000000000000000000000..a1155bcd6c50dcf53c4a91ca0346156da9d414d1
--- /dev/null
+++ b/tools/ui/node_modules/rehype-stringify/lib/index.d.ts.map
@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,kDALW,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,SAAS,CAiBrB;;IAtBD;;;;;;;OAOG;IACH,sBALW,OAAO,GAAG,IAAI,GAAG,SAAS,EAmBpC;IARC,8DAAwB;;6BApBA,mBAAmB;0BADtB,MAAM"}
\ No newline at end of file
diff --git a/tools/ui/node_modules/rehype-stringify/lib/index.js b/tools/ui/node_modules/rehype-stringify/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..8b9a78eb0ea3f54c78ab548273f1a38a339e2017
--- /dev/null
+++ b/tools/ui/node_modules/rehype-stringify/lib/index.js
@@ -0,0 +1,31 @@
+/**
+ * @import {Root} from 'hast'
+ * @import {Options} from 'hast-util-to-html'
+ * @import {Compiler, Processor} from 'unified'
+ */
+
+import {toHtml} from 'hast-util-to-html'
+
+/**
+ * Plugin to add support for serializing as HTML.
+ *
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function rehypeStringify(options) {
+  /** @type {Processor} */
+  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.
+  const self = this
+  const settings = {...self.data('settings'), ...options}
+
+  self.compiler = compiler
+
+  /**
+   * @type {Compiler}
+   */
+  function compiler(tree) {
+    return toHtml(tree, settings)
+  }
+}
diff --git a/tools/ui/node_modules/rehype-stringify/license b/tools/ui/node_modules/rehype-stringify/license
new file mode 100644
index 0000000000000000000000000000000000000000..e7a45ac737edb9906dc59c57d357f3836cb45ae8
--- /dev/null
+++ b/tools/ui/node_modules/rehype-stringify/license
@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (c) Titus Wormer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/tools/ui/node_modules/rehype-stringify/package.json b/tools/ui/node_modules/rehype-stringify/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..78be928e13d0539abb4da506b20a740d0fafbce0
--- /dev/null
+++ b/tools/ui/node_modules/rehype-stringify/package.json
@@ -0,0 +1,51 @@
+{
+  "name": "rehype-stringify",
+  "version": "10.0.1",
+  "description": "rehype plugin to serialize HTML",
+  "license": "MIT",
+  "keywords": [
+    "abstract",
+    "ast",
+    "compile",
+    "html",
+    "plugin",
+    "rehype",
+    "rehype-plugin",
+    "serialize",
+    "stringify",
+    "syntax",
+    "tree",
+    "unified"
+  ],
+  "homepage": "https://github.com/rehypejs/rehype",
+  "repository": "https://github.com/rehypejs/rehype/tree/main/packages/rehype-stringify",
+  "bugs": "https://github.com/rehypejs/rehype/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Titus Wormer  (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer  (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./index.js",
+  "files": [
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "@types/hast": "^3.0.0",
+    "hast-util-to-html": "^9.0.0",
+    "unified": "^11.0.0"
+  },
+  "scripts": {},
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "strict": true,
+    "ignoreCatch": true
+  }
+}
diff --git a/tools/ui/node_modules/rehype-stringify/readme.md b/tools/ui/node_modules/rehype-stringify/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..569e44ca32ad90b850733db01fb35eb4ac828905
--- /dev/null
+++ b/tools/ui/node_modules/rehype-stringify/readme.md
@@ -0,0 +1,442 @@
+# rehype-stringify
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][sponsors-badge]][collective]
+[![Backers][backers-badge]][collective]
+[![Chat][chat-badge]][chat]
+
+**[rehype][]** plugin to add support for serializing to HTML.
+
+## Contents
+
+* [What is this?](#what-is-this)
+* [When should I use this?](#when-should-i-use-this)
+* [Install](#install)
+* [Use](#use)
+* [API](#api)
+  * [`unified().use(rehypeStringify[, options])`](#unifieduserehypestringify-options)
+  * [`CharacterReferences`](#characterreferences)
+  * [`Options`](#options)
+* [Syntax](#syntax)
+* [Syntax tree](#syntax-tree)
+* [Types](#types)
+* [Compatibility](#compatibility)
+* [Security](#security)
+* [Contribute](#contribute)
+* [Sponsor](#sponsor)
+* [License](#license)
+
+## What is this?
+
+This package is a [unified][] ([rehype][]) plugin that defines how to take a
+syntax tree as input and turn it into serialized HTML.
+When it’s used, HTML is serialized as the final result.
+
+See [the monorepo readme][rehype] for info on what the rehype ecosystem is.
+
+## When should I use this?
+
+This plugin adds support to unified for serializing HTML.
+If you also need to parse HTML, you can alternatively use
+[`rehype`][rehype-core], which combines unified,
+[`rehype-parse`][rehype-parse], and this plugin.
+
+When you are in a browser, trust your content, don’t need formatting options,
+and value a smaller bundle size, you can use
+[`rehype-dom-stringify`][rehype-dom-stringify] instead.
+
+If you don’t use plugins and have access to a syntax tree, you can directly use
+[`hast-util-to-html`][hast-util-to-html], which is used inside this plugin.
+rehype focusses on making it easier to transform content by abstracting such
+internals away.
+
+A different plugin, [`rehype-format`][rehype-format], improves the readability
+of HTML source code as it adds insignificant but pretty whitespace between
+elements.
+There is also the preset [`rehype-minify`][rehype-minify] for when you want the
+inverse: minified and mangled HTML.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install rehype-stringify
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import rehypeStringify from 'https://esm.sh/rehype-stringify@10'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+
+```
+
+## Use
+
+Say we have the following module `example.js`:
+
+```js
+import remarkRehype from 'remark-rehype'
+import rehypeStringify from 'rehype-stringify'
+import remarkGfm from 'remark-gfm'
+import remarkParse from 'remark-parse'
+import {unified} from 'unified'
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkGfm)
+  .use(remarkRehype)
+  .use(rehypeStringify)
+  .process('# Hi\n\n*Hello*, world!')
+
+console.log(String(file))
+```
+
+…running that with `node example.js` yields:
+
+```html
+
Hi

+
Hello, world!

+```
+
+## API
+
+This package exports no identifiers.
+The default export is [`rehypeStringify`][api-rehype-stringify].
+
+### `unified().use(rehypeStringify[, options])`
+
+Plugin to add support for serializing to HTML.
+
+###### Parameters
+
+* `options` ([`Options`][api-options], optional)
+  — configuration
+
+###### Returns
+
+Nothing (`undefined`).
+
+### `CharacterReferences`
+
+How to serialize character references (TypeScript type).
+
+> ⚠️ **Note**: `omitOptionalSemicolons` creates what HTML calls “parse errors”
+> but is otherwise still valid HTML — don’t use this except when building a
+> minifier.
+> Omitting semicolons is possible for certain named and numeric references in
+> some cases.
+
+> ⚠️ **Note**: `useNamedReferences` can be omitted when using
+> `useShortestReferences`.
+
+###### Fields
+
+* `useNamedReferences` (`boolean`, default: `false`)
+  — prefer named character references (`&`) where possible
+* `omitOptionalSemicolons` (`boolean`, default: `false`)
+  — whether to omit semicolons when possible
+* `useShortestReferences` (`boolean`, default: `false`)
+  — prefer the shortest possible reference, if that results in less bytes
+
+### `Options`
+
+Configuration (TypeScript type).
+
+> ⚠️ **Danger**: only set `allowDangerousCharacters` and `allowDangerousHtml` if
+> you completely trust the content.
+
+> 👉 **Note**: `allowParseErrors`, `bogusComments`, `tightAttributes`, and
+> `tightDoctype`
+> intentionally create parse errors in markup (how parse errors are handled is
+> well defined, so this works but isn’t pretty).
+
+> 👉 **Note**: this is not an XML serializer.
+> It supports SVG as embedded in HTML.
+> It does not support the features available in XML.
+> Use [`xast-util-to-xml`][xast-util-to-xml] to serialize XML.
+
+###### Fields
+
+* `allowDangerousCharacters` (`boolean`, default: `false`)
+  — do not encode some characters which cause XSS vulnerabilities in older
+  browsers
+* `allowDangerousHtml` (`boolean`, default: `false`)
+  — allow [`Raw`][raw] nodes and insert them as raw HTML; when `false`, `Raw`
+  nodes are encoded
+* `allowParseErrors` (`boolean`, default: `false`)
+  — do not encode characters which cause parse errors (even though they
+  work), to save bytes; not used in the SVG space.
+* `bogusComments` (`boolean`, default: `false`)
+  — use “bogus comments” instead of comments to save byes: ``
+  instead of ``
+* `characterReferences` ([`CharacterReferences`][api-character-references],
+  optional)
+  — configure how to serialize character references
+* `closeEmptyElements` (`boolean`, default: `false`)
+  — close SVG elements without any content with slash (`/`) on the opening
+  tag instead of an end tag: `` instead of ``;
+  see `tightSelfClosing` to control whether a space is used before the slash;
+  not used in the HTML space
+* `closeSelfClosing` (`boolean`, default: `false`)
+  — close self-closing nodes with an extra slash (`/`): `` instead of
+  ``; see `tightSelfClosing` to control whether a space is used before
+  the slash; not used in the SVG space.
+* `collapseEmptyAttributes` (`boolean`, default: `false`)
+  — collapse empty attributes: get `class` instead of `class=""`; not used in
+  the SVG space; boolean attributes (such as `hidden`) are always collapsed
+* `omitOptionalTags` (`boolean`, default: `false`)
+  — omit optional opening and closing tags; to illustrate, in
+  `
  1. one
  2. two
`, both `` closing tags can be
+  omitted, the first because it’s followed by another `li`, the last because
+  it’s followed by nothing; not used in the SVG space
+* `preferUnquoted` (`boolean`, default: `false`)
+  — leave attributes unquoted if that results in less bytes; not used in the
+  SVG space
+* `quote` (`'"'` or `"'"`, default: `'"'`)
+  — preferred quote to use
+* `quoteSmart` (`boolean`, default: `false`)
+  — use the other quote if that results in less bytes
+* `space` (`'html'` or `'svg'`, default: `'html'`)
+  — which space the document is in; when an `` element is found in the
+  HTML space, this package already automatically switches to and from the SVG
+* `tightAttributes` (`boolean`, default: `false`)
+  — join attributes together, without whitespace, if possible: get
+  `class="a b"title="c d"` instead of `class="a b" title="c d"` to save
+  bytes; not used in the SVG space
+* `tightCommaSeparatedLists` (`boolean`, default: `false`)
+  — join known comma-separated attribute values with just a comma (`,`),
+  instead of padding them on the right as well (`,␠`, where `␠` represents a
+  space)
+* `tightDoctype` (`boolean`, default: `false`)
+  — drop unneeded spaces in doctypes: `` instead of
+  `` to save bytes
+* `tightSelfClosing` (`boolean`, default: `false`).
+  — do not use an extra space when closing self-closing elements: ``
+  instead of ``; only used if `closeSelfClosing: true` or
+  `closeEmptyElements: true`
+* `upperDoctype` (`boolean`, default: `false`).
+  — use a ``, default:
+  [`html-void-elements`][html-void-elements])
+  — tag names of elements to serialize without closing tag; not used in the
+  SVG space
+
+## Syntax
+
+HTML is serialized according to WHATWG HTML (the living standard), which is also
+followed by all browsers.
+
+## Syntax tree
+
+The syntax tree format used in rehype is [hast][].
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional types
+[`CharacterReferences`][api-character-references] and
+[`Options`][api-options].
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line, `rehype-stringify@^10`,
+compatible with Node.js 16.
+
+## Security
+
+As **rehype** works on HTML, and improper use of HTML can open you up to a
+[cross-site scripting (XSS)][xss] attack, use of rehype can also be unsafe.
+Use [`rehype-sanitize`][rehype-sanitize] to make the tree safe.
+
+Use of rehype plugins could also open you up to other attacks.
+Carefully assess each plugin and the risks involved in using them.
+
+For info on how to submit a report, see our [security policy][security].
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`rehypejs/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## Sponsor
+
+Support this effort and give back by sponsoring on [OpenCollective][collective]!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+  Vercel


+  
+		
+  Motif


+  
+		
+  HashiCorp


+  
+		
+  GitBook


+  
+		
+  Gatsby


+  
+

+  Netlify


+  
+  
+		
+  Coinbase


+  
+		
+  ThemeIsle


+  
+		
+  Expo


+  
+		
+  Boost Note


+  
+		
+  Markdown Space


+  
+		
+  Holloway


+  
+

+  

+  You?
+  


+

+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+
+
+[build-badge]: https://github.com/rehypejs/rehype/workflows/main/badge.svg
+
+[build]: https://github.com/rehypejs/rehype/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/rehypejs/rehype.svg
+
+[coverage]: https://codecov.io/github/rehypejs/rehype
+
+[downloads-badge]: https://img.shields.io/npm/dm/rehype-stringify.svg
+
+[downloads]: https://www.npmjs.com/package/rehype-stringify
+
+[size-badge]: https://img.shields.io/bundlejs/size/rehype-stringify
+
+[size]: https://bundlejs.com/?q=rehype-stringify
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[collective]: https://opencollective.com/unified
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/rehypejs/rehype/discussions
+
+[health]: https://github.com/rehypejs/.github
+
+[security]: https://github.com/rehypejs/.github/blob/main/security.md
+
+[contributing]: https://github.com/rehypejs/.github/blob/main/contributing.md
+
+[support]: https://github.com/rehypejs/.github/blob/main/support.md
+
+[coc]: https://github.com/rehypejs/.github/blob/main/code-of-conduct.md
+
+[license]: https://github.com/rehypejs/rehype/blob/main/license
+
+[author]: https://wooorm.com
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esmsh]: https://esm.sh
+
+[unified]: https://github.com/unifiedjs/unified
+
+[rehype]: https://github.com/rehypejs/rehype
+
+[hast]: https://github.com/syntax-tree/hast
+
+[xss]: https://en.wikipedia.org/wiki/Cross-site_scripting
+
+[typescript]: https://www.typescriptlang.org
+
+[rehype-parse]: ../rehype-parse/
+
+[rehype-core]: ../rehype/
+
+[rehype-sanitize]: https://github.com/rehypejs/rehype-sanitize
+
+[rehype-format]: https://github.com/rehypejs/rehype-format
+
+[rehype-minify]: https://github.com/rehypejs/rehype-minify
+
+[rehype-dom-stringify]: https://github.com/rehypejs/rehype-dom/tree/main/packages/rehype-dom-stringify
+
+[hast-util-to-html]: https://github.com/syntax-tree/hast-util-to-html
+
+[xast-util-to-xml]: https://github.com/syntax-tree/xast-util-to-xml
+
+[html-void-elements]: https://github.com/wooorm/html-void-elements
+
+
+
+[raw]: https://github.com/syntax-tree/mdast-util-to-hast?tab=readme-ov-file#raw
+
+[api-character-references]: #characterreferences
+
+[api-options]: #options
+
+[api-rehype-stringify]: #unifieduserehypestringify-options
diff --git a/tools/ui/node_modules/remark-breaks/index.d.ts b/tools/ui/node_modules/remark-breaks/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bc0a95d5247ec176397532b3cdba4bc348fb71b6
--- /dev/null
+++ b/tools/ui/node_modules/remark-breaks/index.d.ts
@@ -0,0 +1 @@
+export { default } from "./lib/index.js";
diff --git a/tools/ui/node_modules/remark-breaks/index.js b/tools/ui/node_modules/remark-breaks/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..dab322b23af0a5d55082684f5e57b622a0646e1d
--- /dev/null
+++ b/tools/ui/node_modules/remark-breaks/index.js
@@ -0,0 +1 @@
+export {default} from './lib/index.js'
diff --git a/tools/ui/node_modules/remark-breaks/lib/index.d.ts b/tools/ui/node_modules/remark-breaks/lib/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..38e52151599e63e85eea8008c37577cd466045c5
--- /dev/null
+++ b/tools/ui/node_modules/remark-breaks/lib/index.d.ts
@@ -0,0 +1,9 @@
+/**
+ * Support hard breaks without needing spaces or escapes (turns enters into
+ * `
`s).
+ *
+ * @returns
+ *   Transform.
+ */
+export default function remarkBreaks(): (tree: Root) => undefined;
+export type Root = import('mdast').Root;
diff --git a/tools/ui/node_modules/remark-breaks/lib/index.js b/tools/ui/node_modules/remark-breaks/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..de2149cc16eeea31ac31481e5c09901c0eeb8632
--- /dev/null
+++ b/tools/ui/node_modules/remark-breaks/lib/index.js
@@ -0,0 +1,26 @@
+/**
+ * @typedef {import('mdast').Root} Root
+ */
+
+import {newlineToBreak} from 'mdast-util-newline-to-break'
+
+/**
+ * Support hard breaks without needing spaces or escapes (turns enters into
+ * `
`s).
+ *
+ * @returns
+ *   Transform.
+ */
+export default function remarkBreaks() {
+  /**
+   * Transform.
+   *
+   * @param {Root} tree
+   *   Tree.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  return function (tree) {
+    newlineToBreak(tree)
+  }
+}
diff --git a/tools/ui/node_modules/remark-breaks/license b/tools/ui/node_modules/remark-breaks/license
new file mode 100644
index 0000000000000000000000000000000000000000..045ffe0e075da471f1b04e204acce031b22d1c13
--- /dev/null
+++ b/tools/ui/node_modules/remark-breaks/license
@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2017 Titus Wormer 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/tools/ui/node_modules/remark-breaks/package.json b/tools/ui/node_modules/remark-breaks/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..5ecc4a015b76c8af5efc20bd82459bcc4654df12
--- /dev/null
+++ b/tools/ui/node_modules/remark-breaks/package.json
@@ -0,0 +1,93 @@
+{
+  "name": "remark-breaks",
+  "version": "4.0.0",
+  "description": "remark plugin to add break support, without needing spaces",
+  "license": "MIT",
+  "keywords": [
+    "break",
+    "linefeed",
+    "markdown",
+    "mdast",
+    "newline",
+    "plugin",
+    "remark",
+    "remark-plugin",
+    "unified"
+  ],
+  "repository": "remarkjs/remark-breaks",
+  "bugs": "https://github.com/remarkjs/remark-breaks/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Titus Wormer  (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer  (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./index.js",
+  "files": [
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "@types/mdast": "^4.0.0",
+    "mdast-util-newline-to-break": "^2.0.0",
+    "unified": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "c8": "^8.0.0",
+    "prettier": "^3.0.0",
+    "rehype-stringify": "^10.0.0",
+    "remark-cli": "^11.0.0",
+    "remark-parse": "^11.0.0",
+    "remark-preset-wooorm": "^9.0.0",
+    "remark-rehype": "^11.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^5.0.0",
+    "xo": "^0.56.0"
+  },
+  "scripts": {
+    "build": "tsc --build --clean && tsc --build && type-coverage",
+    "format": "remark . --frail --output --quiet && prettier . --log-level warn --write && xo --fix",
+    "prepack": "npm run build && npm run format",
+    "test": "npm run build && npm run format && npm run test-coverage",
+    "test-api": "node --conditions development test.js",
+    "test-coverage": "c8 --100 --reporter lcov npm run test-api"
+  },
+  "prettier": {
+    "bracketSpacing": false,
+    "singleQuote": true,
+    "semi": false,
+    "tabWidth": 2,
+    "trailingComma": "none",
+    "useTabs": false
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-wooorm"
+    ]
+  },
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "ignoreCatch": true,
+    "strict": true
+  },
+  "xo": {
+    "overrides": [
+      {
+        "files": [
+          "test.js"
+        ],
+        "rules": {
+          "no-await-in-loop": "off"
+        }
+      }
+    ],
+    "prettier": true
+  }
+}
diff --git a/tools/ui/node_modules/remark-breaks/readme.md b/tools/ui/node_modules/remark-breaks/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..97f79a82b4c32269f414214a0ea26ac2f6a50dd2
--- /dev/null
+++ b/tools/ui/node_modules/remark-breaks/readme.md
@@ -0,0 +1,266 @@
+# remark-breaks
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][sponsors-badge]][collective]
+[![Backers][backers-badge]][collective]
+[![Chat][chat-badge]][chat]
+
+**[remark][]** plugin to support hard breaks without needing spaces or escapes
+(turns enters into `
`s).
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When should I use this?](#when-should-i-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+    *   [`unified().use(remarkBreaks)`](#unifieduseremarkbreaks)
+*   [Syntax](#syntax)
+*   [Syntax tree](#syntax-tree)
+*   [Types](#types)
+*   [Compatibility](#compatibility)
+*   [Security](#security)
+*   [Related](#related)
+*   [Contribute](#contribute)
+*   [License](#license)
+
+## What is this?
+
+This package is a [unified][] ([remark][]) plugin to turn soft line endings
+(enters) into hard breaks (`
`s)
+
+## When should I use this?
+
+This plugin is useful if you want to display user content closer to how it was
+authored, because when a user includes a line ending, it’ll show as such.
+GitHub does this in a few places (comments, issues, PRs, and releases), but it’s
+not semantic according to HTML and not compliant to markdown.
+Markdown already has two ways to include hard breaks, namely trailing spaces and
+escapes (note that `␠` represents a normal space):
+
+```markdown
+lorem␠␠
+ipsum
+
+lorem\
+ipsum
+```
+
+Both will turn into `
`s.
+If you control who authors content or can document how markdown works, it’s
+recommended to use escapes instead.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install remark-breaks
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import remarkBreaks from 'https://esm.sh/remark-breaks@4'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+
+```
+
+## Use
+
+Say we have the following file `example.md` (note: there are no spaces after
+`a`):
+
+```markdown
+Mars is
+the fourth planet
+```
+
+…and a module `example.js`:
+
+```js
+import rehypeStringify from 'rehype-stringify'
+import remarkBreaks from 'remark-breaks'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import {read} from 'to-vfile'
+import {unified} from 'unified'
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkBreaks)
+  .use(remarkRehype)
+  .use(rehypeStringify)
+  .process(await read('example.md'))
+
+console.log(String(file))
+```
+
+…then running `node example.js` yields:
+
+```html
+
Mars is

+the fourth planet

+```
+
+> 👉 **Note**: Without `remark-breaks`, you’d get:
+>
+> ```html
+> 
Mars is
+> the fourth planet

+> ```
+
+## API
+
+This package exports no identifiers.
+The default export is [`remarkBreaks`][api-remark-breaks].
+
+### `unified().use(remarkBreaks)`
+
+Support hard breaks without needing spaces or escapes (turns enters into
+`
`s).
+
+###### Parameters
+
+There are no parameters.
+
+###### Returns
+
+Transform ([`Transformer`][unified-transformer]).
+
+## Syntax
+
+This plugin looks for markdown line endings (`\r`, `\n`, and `\r\n`) preceded
+by zero or more spaces and tabs.
+
+## Syntax tree
+
+This plugin adds mdast [`Break`][mdast-break] nodes to the syntax tree.
+These are the same nodes that represent breaks with spaces or escapes.
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports no additional types.
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line, `remark-breaks@^4`,
+compatible with Node.js 16.
+
+This plugin works with `unified` version 6+ and `remark` version 7+.
+
+## Security
+
+Use of `remark-breaks` does not involve **[rehype][]** (**[hast][]**) or user
+content so there are no openings for [cross-site scripting (XSS)][wiki-xss]
+attacks.
+
+## Related
+
+*   [`remark-gfm`](https://github.com/remarkjs/remark-gfm)
+    — support GFM (autolink literals, footnotes, strikethrough, tables,
+    tasklists)
+*   [`remark-github`](https://github.com/remarkjs/remark-github)
+    — link references to commits, issues, and users, in the same way that
+    GitHub does
+*   [`remark-directive`](https://github.com/remarkjs/remark-directive)
+    — support directives
+*   [`remark-frontmatter`](https://github.com/remarkjs/remark-frontmatter)
+    — support frontmatter (YAML, TOML, and more)
+*   [`remark-math`](https://github.com/remarkjs/remark-math)
+    — support math
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`remarkjs/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+
+
+[build-badge]: https://github.com/remarkjs/remark-breaks/workflows/main/badge.svg
+
+[build]: https://github.com/remarkjs/remark-breaks/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/remarkjs/remark-breaks.svg
+
+[coverage]: https://codecov.io/github/remarkjs/remark-breaks
+
+[downloads-badge]: https://img.shields.io/npm/dm/remark-breaks.svg
+
+[downloads]: https://www.npmjs.com/package/remark-breaks
+
+[size-badge]: https://img.shields.io/bundlejs/size/remark-breaks
+
+[size]: https://bundlejs.com/?q=remark-breaks
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[collective]: https://opencollective.com/unified
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/remarkjs/remark/discussions
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[health]: https://github.com/remarkjs/.github
+
+[contributing]: https://github.com/remarkjs/.github/blob/main/contributing.md
+
+[support]: https://github.com/remarkjs/.github/blob/main/support.md
+
+[coc]: https://github.com/remarkjs/.github/blob/main/code-of-conduct.md
+
+[license]: license
+
+[author]: https://wooorm.com
+
+[hast]: https://github.com/syntax-tree/hast
+
+[mdast-break]: https://github.com/syntax-tree/mdast#break
+
+[rehype]: https://github.com/rehypejs/rehype
+
+[remark]: https://github.com/remarkjs/remark
+
+[typescript]: https://www.typescriptlang.org
+
+[unified]: https://github.com/unifiedjs/unified
+
+[unified-transformer]: https://github.com/unifiedjs/unified#transformer
+
+[wiki-xss]: https://en.wikipedia.org/wiki/Cross-site_scripting
+
+[api-remark-breaks]: #unifieduseremarkbreaks
diff --git a/tools/ui/node_modules/remark-gfm/index.d.ts b/tools/ui/node_modules/remark-gfm/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..094e9ae9379f52d82d0e80436eae6ad1b2bfdd9a
--- /dev/null
+++ b/tools/ui/node_modules/remark-gfm/index.d.ts
@@ -0,0 +1,13 @@
+import type {Options as MicromarkOptions} from 'micromark-extension-gfm'
+import type {Options as MdastOptions} from 'mdast-util-gfm'
+
+export {default} from './lib/index.js'
+
+/**
+ * Configuration for `remark-gfm`.
+ *
+ * Currently supports `singleTilde` as a parse option and
+ * `firstLineBlank`, `stringLength`, `tableCellPadding`, and `tablePipeAlign`
+ * as serialization options.
+ */
+export interface Options extends MicromarkOptions, MdastOptions {}
diff --git a/tools/ui/node_modules/remark-gfm/index.js b/tools/ui/node_modules/remark-gfm/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a4c25d60f746eac9b80f56076fa90be149881a2
--- /dev/null
+++ b/tools/ui/node_modules/remark-gfm/index.js
@@ -0,0 +1,2 @@
+// Note: types exposed from `index.d.ts`.
+export {default} from './lib/index.js'
diff --git a/tools/ui/node_modules/remark-gfm/lib/index.d.ts b/tools/ui/node_modules/remark-gfm/lib/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a78b76b66d36ea295f5eed44d8b2eac4f359ef60
--- /dev/null
+++ b/tools/ui/node_modules/remark-gfm/lib/index.d.ts
@@ -0,0 +1,12 @@
+/**
+ * Add support GFM (autolink literals, footnotes, strikethrough, tables,
+ * tasklists).
+ *
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function remarkGfm(options?: Options | null | undefined): undefined;
+import type { Options } from 'remark-gfm';
+//# sourceMappingURL=index.d.ts.map
\ No newline at end of file
diff --git a/tools/ui/node_modules/remark-gfm/lib/index.d.ts.map b/tools/ui/node_modules/remark-gfm/lib/index.d.ts.map
new file mode 100644
index 0000000000000000000000000000000000000000..d5c64fb562b1a0114c5416fd28db58b9b44a3a1b
--- /dev/null
+++ b/tools/ui/node_modules/remark-gfm/lib/index.d.ts.map
@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAcA;;;;;;;;GAQG;AACH,4CALW,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,SAAS,CAoBrB;6BAtCyB,YAAY"}
\ No newline at end of file
diff --git a/tools/ui/node_modules/remark-gfm/lib/index.js b/tools/ui/node_modules/remark-gfm/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..ee1cca2459792a0ae24518470163f6244f23a06a
--- /dev/null
+++ b/tools/ui/node_modules/remark-gfm/lib/index.js
@@ -0,0 +1,41 @@
+/**
+ * @import {Root} from 'mdast'
+ * @import {Options} from 'remark-gfm'
+ * @import {} from 'remark-parse'
+ * @import {} from 'remark-stringify'
+ * @import {Processor} from 'unified'
+ */
+
+import {gfmFromMarkdown, gfmToMarkdown} from 'mdast-util-gfm'
+import {gfm} from 'micromark-extension-gfm'
+
+/** @type {Options} */
+const emptyOptions = {}
+
+/**
+ * Add support GFM (autolink literals, footnotes, strikethrough, tables,
+ * tasklists).
+ *
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function remarkGfm(options) {
+  // @ts-expect-error: TS is wrong about `this`.
+  // eslint-disable-next-line unicorn/no-this-assignment
+  const self = /** @type {Processor} */ (this)
+  const settings = options || emptyOptions
+  const data = self.data()
+
+  const micromarkExtensions =
+    data.micromarkExtensions || (data.micromarkExtensions = [])
+  const fromMarkdownExtensions =
+    data.fromMarkdownExtensions || (data.fromMarkdownExtensions = [])
+  const toMarkdownExtensions =
+    data.toMarkdownExtensions || (data.toMarkdownExtensions = [])
+
+  micromarkExtensions.push(gfm(settings))
+  fromMarkdownExtensions.push(gfmFromMarkdown())
+  toMarkdownExtensions.push(gfmToMarkdown(settings))
+}
diff --git a/tools/ui/node_modules/remark-gfm/license b/tools/ui/node_modules/remark-gfm/license
new file mode 100644
index 0000000000000000000000000000000000000000..bc8f165a62768a19de38901d81ac662c51ff29db
--- /dev/null
+++ b/tools/ui/node_modules/remark-gfm/license
@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) Titus Wormer 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/tools/ui/node_modules/remark-gfm/package.json b/tools/ui/node_modules/remark-gfm/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..bb536e513cabd67ecfda24294b91f098df07ed81
--- /dev/null
+++ b/tools/ui/node_modules/remark-gfm/package.json
@@ -0,0 +1,125 @@
+{
+  "author": "Titus Wormer  (https://wooorm.com)",
+  "bugs": "https://github.com/remarkjs/remark-gfm/issues",
+  "contributors": [
+    "Titus Wormer  (https://wooorm.com)"
+  ],
+  "dependencies": {
+    "@types/mdast": "^4.0.0",
+    "mdast-util-gfm": "^3.0.0",
+    "micromark-extension-gfm": "^3.0.0",
+    "remark-parse": "^11.0.0",
+    "remark-stringify": "^11.0.0",
+    "unified": "^11.0.0"
+  },
+  "description": "remark plugin to support GFM (autolink literals, footnotes, strikethrough, tables, tasklists)",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "c8": "^10.0.0",
+    "is-hidden": "^2.0.0",
+    "prettier": "^3.0.0",
+    "remark": "^15.0.0",
+    "remark-cli": "^12.0.0",
+    "remark-preset-wooorm": "^11.0.0",
+    "string-width": "^6.0.0",
+    "to-vfile": "^8.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^5.0.0",
+    "xo": "^0.60.0"
+  },
+  "exports": "./index.js",
+  "files": [
+    "index.d.ts",
+    "index.js",
+    "lib/"
+  ],
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "keywords": [
+    "autolink",
+    "footnote",
+    "gfm",
+    "github",
+    "markdown",
+    "mdast",
+    "plugin",
+    "remark",
+    "remark-plugin",
+    "strikethrough",
+    "table",
+    "tasklist",
+    "unified"
+  ],
+  "license": "MIT",
+  "name": "remark-gfm",
+  "prettier": {
+    "bracketSpacing": false,
+    "singleQuote": true,
+    "semi": false,
+    "tabWidth": 2,
+    "trailingComma": "none",
+    "useTabs": false
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-wooorm"
+    ]
+  },
+  "repository": "remarkjs/remark-gfm",
+  "scripts": {
+    "build": "tsc --build --clean && tsc --build && type-coverage",
+    "format": "remark . --frail --output --quiet && prettier . --log-level warn --write && xo --fix",
+    "prepack": "npm run build && npm run format",
+    "test": "npm run build && npm run format && npm run test-coverage",
+    "test-api": "node --conditions development test/index.js",
+    "test-coverage": "c8 --100 --reporter lcov npm run test-api"
+  },
+  "sideEffects": false,
+  "typeCoverage": {
+    "atLeast": 100,
+    "strict": true
+  },
+  "type": "module",
+  "version": "4.0.1",
+  "xo": {
+    "overrides": [
+      {
+        "files": [
+          "**/*.d.ts"
+        ],
+        "rules": {
+          "@typescript-eslint/array-type": [
+            "error",
+            {
+              "default": "generic"
+            }
+          ],
+          "@typescript-eslint/ban-types": [
+            "error",
+            {
+              "extendDefaults": true
+            }
+          ],
+          "@typescript-eslint/consistent-type-definitions": [
+            "error",
+            "interface"
+          ]
+        }
+      },
+      {
+        "files": [
+          "test/**/*.js"
+        ],
+        "rules": {
+          "no-await-in-loop": "off"
+        }
+      }
+    ],
+    "prettier": true,
+    "rules": {
+      "logical-assignment-operators": "off"
+    }
+  }
+}
diff --git a/tools/ui/node_modules/remark-gfm/readme.md b/tools/ui/node_modules/remark-gfm/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..98ca7de7fad0c58dc071136a22c3b2272616b825
--- /dev/null
+++ b/tools/ui/node_modules/remark-gfm/readme.md
@@ -0,0 +1,518 @@
+# remark-gfm
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][sponsors-badge]][collective]
+[![Backers][backers-badge]][collective]
+[![Chat][chat-badge]][chat]
+
+**[remark][]** plugin to support [GFM][] (autolink literals, footnotes,
+strikethrough, tables, tasklists).
+
+## Contents
+
+* [What is this?](#what-is-this)
+* [When should I use this?](#when-should-i-use-this)
+* [Install](#install)
+* [Use](#use)
+* [API](#api)
+  * [`unified().use(remarkGfm[, options])`](#unifieduseremarkgfm-options)
+  * [`Options`](#options)
+* [Examples](#examples)
+  * [Example: `singleTilde`](#example-singletilde)
+  * [Example: `stringLength`](#example-stringlength)
+* [Bugs](#bugs)
+* [Authoring](#authoring)
+* [HTML](#html)
+* [CSS](#css)
+* [Syntax](#syntax)
+* [Syntax tree](#syntax-tree)
+* [Types](#types)
+* [Compatibility](#compatibility)
+* [Security](#security)
+* [Related](#related)
+* [Contribute](#contribute)
+* [License](#license)
+
+## What is this?
+
+This package is a [unified][] ([remark][]) plugin to enable the extensions to
+markdown that GitHub adds with GFM: autolink literals (`www.x.com`), footnotes
+(`[^1]`), strikethrough (`~~stuff~~`), tables (`| cell |…`), and tasklists
+(`* [x]`).
+You can use this plugin to add support for parsing and serializing them.
+These extensions by GitHub to CommonMark are called [GFM][] (GitHub Flavored
+Markdown).
+
+This plugin does not handle how markdown is turned to HTML.
+That’s done by [`remark-rehype`][remark-rehype].
+If your content is not in English and uses footnotes, you should configure that
+plugin.
+When generating HTML, you might also want to enable [`rehype-slug`][rehype-slug]
+to add `id`s on headings.
+
+A different plugin, [`remark-frontmatter`][remark-frontmatter], adds support for
+frontmatter.
+GitHub supports YAML frontmatter for files in repos and Gists but they don’t
+treat it as part of GFM.
+
+Another plugin, [`remark-github`][remark-github], adds support for how markdown
+works in relation to a certain GitHub repo in comments, issues, PRs, and
+releases, by linking references to commits, issues, and users.
+
+Yet another plugin, [`remark-breaks`][remark-breaks], turns soft line endings
+(enters) into hard breaks (`
`s).
+GitHub does this in a few places (comments, issues, PRs, and releases).
+
+## When should I use this?
+
+This project is useful when you want to support the same features that GitHub
+does in files in a repo, Gists, and several other places.
+Users frequently believe that some of these extensions, specifically autolink
+literals and tables, are part of normal markdown, so using `remark-gfm` will
+help match your implementation to their understanding of markdown.
+There are several edge cases where GitHub’s implementation works in unexpected
+ways or even different than described in their spec, so *writing* in GFM is not
+always the best choice.
+
+If you *just* want to turn markdown into HTML (with maybe a few extensions such
+as GFM), we recommend [`micromark`][micromark] with
+[`micromark-extension-gfm`][micromark-extension-gfm] instead.
+If you don’t use plugins and want to access the syntax tree, you can use
+[`mdast-util-from-markdown`][mdast-util-from-markdown] with
+[`mdast-util-gfm`][mdast-util-gfm].
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install remark-gfm
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import remarkGfm from 'https://esm.sh/remark-gfm@4'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+
+```
+
+## Use
+
+Say our document `example.md` contains:
+
+```markdown
+# GFM
+
+## Autolink literals
+
+www.example.com, https://example.com, and contact@example.com.
+
+## Footnote
+
+A note[^1]
+
+[^1]: Big note.
+
+## Strikethrough
+
+~one~ or ~~two~~ tildes.
+
+## Table
+
+| a | b  |  c |  d  |
+| - | :- | -: | :-: |
+
+## Tasklist
+
+* [ ] to do
+* [x] done
+```
+
+…and our module `example.js` contains:
+
+```js
+import rehypeStringify from 'rehype-stringify'
+import remarkGfm from 'remark-gfm'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import {read} from 'to-vfile'
+import {unified} from 'unified'
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkGfm)
+  .use(remarkRehype)
+  .use(rehypeStringify)
+  .process(await read('example.md'))
+
+console.log(String(file))
+```
+
+…then running `node example.js` yields:
+
+```html
+
GFM

+
Autolink literals

+
www.example.com, https://example.com, and contact@example.com.

+
Footnote

+
A note1

+
Strikethrough

+
one or two tildes.

+
Table

+
+
+
+
+
+
+
+
+
+
abcd

+
Tasklist

+
    
+
  •  to do
    • 
+
  •  done
    • 
+

+
Footnotes

+
    
+
  1. 
+
    Big note. ↩
    
+
    2. 
+

+

+```
+
+## API
+
+This package exports no identifiers.
+The default export is [`remarkGfm`][api-remark-gfm].
+
+### `unified().use(remarkGfm[, options])`
+
+Add support GFM (autolink literals, footnotes, strikethrough, tables,
+tasklists).
+
+###### Parameters
+
+* `options` ([`Options`][api-options], optional)
+  — configuration
+
+###### Returns
+
+Nothing (`undefined`).
+
+### `Options`
+
+Configuration (TypeScript type).
+
+###### Fields
+
+* `firstLineBlank` (`boolean`, default: `false`)
+  — serialize with a blank line for the first line of footnote definitions
+* `stringLength` (`((value: string) => number)`, default: `d => d.length`)
+  — detect the size of table cells, used when aligning cells
+* `singleTilde` (`boolean`, default: `true`)
+  — whether to support strikethrough with a single tilde;
+  single tildes work on github.com, but are technically prohibited by GFM;
+  you can always use 2 or more tildes for strikethrough
+* `tablePipeAlign` (`boolean`, default: `true`)
+  — whether to align table pipes
+* `tableCellPadding` (`boolean`, default: `true`)
+  — whether to add a space of padding between table pipes and cells
+
+## Examples
+
+### Example: `singleTilde`
+
+To turn off support for parsing strikethrough with single tildes, pass
+`singleTilde: false`:
+
+```js
+// …
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkGfm, {singleTilde: false})
+  .use(remarkRehype)
+  .use(rehypeStringify)
+  .process('~one~ and ~~two~~')
+
+console.log(String(file))
+```
+
+Yields:
+
+```html
+
~one~ and two

+```
+
+### Example: `stringLength`
+
+It’s possible to align tables based on the visual width of cells.
+First, let’s show the problem:
+
+```js
+import {remark} from 'remark'
+import remarkGfm from 'remark-gfm'
+
+const input = `| Alpha | Bravo |
+| - | - |
+| 中文 | Charlie |
+| 👩‍❤️‍👩 | Delta |`
+
+const file = await remark().use(remarkGfm).process(input)
+
+console.log(String(file))
+```
+
+The above code shows how remark can be used to format markdown.
+The output is as follows:
+
+```markdown
+| Alpha    | Bravo   |
+| -------- | ------- |
+| 中文       | Charlie |
+| 👩‍❤️‍👩 | Delta   |
+```
+
+To improve the alignment of these full-width characters and emoji, pass a
+`stringLength` function that calculates the visual width of cells.
+One such algorithm is [`string-width`][string-width].
+It can be used like so:
+
+```diff
+@@ -1,5 +1,6 @@
+ import {remark} from 'remark'
+ import remarkGfm from 'remark-gfm'
++import stringWidth from 'string-width'
+
+@@ -10,7 +11,7 @@ async function main() {
+ | 👩‍❤️‍👩 | Delta |`
+
+-const file = await remark().use(remarkGfm).process(input)
++const file = await remark()
++  .use(remarkGfm, {stringLength: stringWidth})
++  .process(input)
+
+   console.log(String(file))
+```
+
+The output of our code with these changes is as follows:
+
+```markdown
+| Alpha | Bravo   |
+| ----- | ------- |
+| 中文  | Charlie |
+| 👩‍❤️‍👩    | Delta   |
+```
+
+## Bugs
+
+For bugs present in GFM but not here, or other peculiarities that are
+supported, see each corresponding readme:
+
+* [autolink literal](https://github.com/micromark/micromark-extension-gfm-autolink-literal#bugs)
+* [footnote](https://github.com/micromark/micromark-extension-gfm-footnote#bugs)
+* strikethrough: n/a
+* [table](https://github.com/micromark/micromark-extension-gfm-table#bugs)
+* tasklists: n/a
+
+## Authoring
+
+For recommendations on how to author GFM, see each corresponding readme:
+
+* [autolink literal](https://github.com/micromark/micromark-extension-gfm-autolink-literal#authoring)
+* [footnote](https://github.com/micromark/micromark-extension-gfm-footnote#authoring)
+* [strikethrough](https://github.com/micromark/micromark-extension-gfm-strikethrough#authoring)
+* [table](https://github.com/micromark/micromark-extension-gfm-table#authoring)
+* [tasklists](https://github.com/micromark/micromark-extension-gfm-task-list-item#authoring)
+
+## HTML
+
+This plugin does not handle how markdown is turned to HTML.
+See [`remark-rehype`][remark-rehype] for how that happens and how to change it.
+
+## CSS
+
+For info on how GitHub styles these features, see each corresponding readme:
+
+* [autolink literal](https://github.com/micromark/micromark-extension-gfm-autolink-literal#css)
+* [footnote](https://github.com/micromark/micromark-extension-gfm-footnote#css)
+* [strikethrough](https://github.com/micromark/micromark-extension-gfm-strikethrough#css)
+* [table](https://github.com/micromark/micromark-extension-gfm-table#css)
+* [tasklists](https://github.com/micromark/micromark-extension-gfm-task-list-item#css)
+
+## Syntax
+
+For info on the syntax of these features, see each corresponding readme:
+
+* [autolink literal](https://github.com/micromark/micromark-extension-gfm-autolink-literal#syntax)
+* [footnote](https://github.com/micromark/micromark-extension-gfm-footnote#syntax)
+* [strikethrough](https://github.com/micromark/micromark-extension-gfm-strikethrough#syntax)
+* [table](https://github.com/micromark/micromark-extension-gfm-table#syntax)
+* [tasklists](https://github.com/micromark/micromark-extension-gfm-task-list-item#syntax)
+
+## Syntax tree
+
+For info on the syntax tree of these features, see each corresponding readme:
+
+* [autolink literal](https://github.com/syntax-tree/mdast-util-gfm-autolink-literal#syntax-tree)
+* [footnote](https://github.com/syntax-tree/mdast-util-gfm-footnote#syntax-tree)
+* [strikethrough](https://github.com/syntax-tree/mdast-util-gfm-strikethrough#syntax-tree)
+* [table](https://github.com/syntax-tree/mdast-util-gfm-table#syntax-tree)
+* [tasklists](https://github.com/syntax-tree/mdast-util-gfm-task-list-item#syntax-tree)
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional type [`Options`][api-options].
+
+The node types are supported in `@types/mdast` by default.
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line, `remark-gfm@^4`, compatible
+with Node.js 16.
+
+This plugin works with `remark-parse` version 11+ (`remark` version 15+).
+The previous version (v3) worked with `remark-parse` version 10 (`remark`
+version 14).
+Before that, v2 worked with `remark-parse` version 9 (`remark` version 13).
+Earlier versions of `remark-parse` and `remark` had a `gfm` option that enabled
+this functionality, which defaulted to true.
+
+## Security
+
+Use of `remark-gfm` does not involve **[rehype][]** ([hast][]) or user
+content so there are no openings for [cross-site scripting (XSS)][wiki-xss]
+attacks.
+
+## Related
+
+* [`remark-github`][remark-github]
+  — link references to commits, issues, PRs, and users
+* [`remark-breaks`][remark-breaks]
+  — support breaks without needing spaces or escapes (enters to `
`)
+* [`remark-frontmatter`][remark-frontmatter]
+  — support frontmatter (YAML, TOML, and more)
+* [`remark-directive`](https://github.com/remarkjs/remark-directive)
+  — support directives
+* [`remark-math`](https://github.com/remarkjs/remark-math)
+  — support math
+* [`remark-mdx`](https://github.com/mdx-js/mdx/tree/main/packages/remark-mdx)
+  — support MDX (ESM, JSX, expressions)
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`remarkjs/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+
+
+[api-options]: #options
+
+[api-remark-gfm]: #unifieduseremarkgfm-options
+
+[author]: https://wooorm.com
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[build]: https://github.com/remarkjs/remark-gfm/actions
+
+[build-badge]: https://github.com/remarkjs/remark-gfm/workflows/main/badge.svg
+
+[chat]: https://github.com/remarkjs/remark/discussions
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[coc]: https://github.com/remarkjs/.github/blob/HEAD/code-of-conduct.md
+
+[collective]: https://opencollective.com/unified
+
+[contributing]: https://github.com/remarkjs/.github/blob/HEAD/contributing.md
+
+[coverage]: https://codecov.io/github/remarkjs/remark-gfm
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/remarkjs/remark-gfm.svg
+
+[downloads]: https://www.npmjs.com/package/remark-gfm
+
+[downloads-badge]: https://img.shields.io/npm/dm/remark-gfm.svg
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[gfm]: https://github.github.com/gfm/
+
+[hast]: https://github.com/syntax-tree/hast
+
+[health]: https://github.com/remarkjs/.github
+
+[license]: license
+
+[mdast-util-from-markdown]: https://github.com/syntax-tree/mdast-util-from-markdown
+
+[mdast-util-gfm]: https://github.com/syntax-tree/mdast-util-gfm
+
+[micromark]: https://github.com/micromark/micromark
+
+[micromark-extension-gfm]: https://github.com/micromark/micromark-extension-gfm
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[rehype]: https://github.com/rehypejs/rehype
+
+[rehype-slug]: https://github.com/rehypejs/rehype-slug
+
+[remark]: https://github.com/remarkjs/remark
+
+[remark-breaks]: https://github.com/remarkjs/remark-breaks
+
+[remark-frontmatter]: https://github.com/remarkjs/remark-frontmatter
+
+[remark-github]: https://github.com/remarkjs/remark-github
+
+[remark-rehype]: https://github.com/remarkjs/remark-rehype
+
+[size]: https://bundlejs.com/?q=remark-gfm
+
+[size-badge]: https://img.shields.io/bundlejs/size/remark-gfm
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[string-width]: https://github.com/sindresorhus/string-width
+
+[support]: https://github.com/remarkjs/.github/blob/HEAD/support.md
+
+[typescript]: https://www.typescriptlang.org
+
+[unified]: https://github.com/unifiedjs/unified
+
+[wiki-xss]: https://en.wikipedia.org/wiki/Cross-site_scripting
diff --git a/tools/ui/node_modules/remark-html/index.d.ts b/tools/ui/node_modules/remark-html/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..528cf8bfa25c5dfa297a5cfcfd1254124a7aa852
--- /dev/null
+++ b/tools/ui/node_modules/remark-html/index.d.ts
@@ -0,0 +1,22 @@
+import type {Root} from 'mdast'
+import type {Plugin} from 'unified'
+import type {Options} from './lib/index.js'
+
+export type {Options} from './lib/index.js'
+
+/**
+ * Add support for serializing to HTML.
+ *
+ * @this
+ *   Unified processor.
+ * @param
+ *   Configuration (optional).
+ * @returns
+ *   Nothing.
+ */
+declare const remarkHtml: Plugin<
+  [(Readonly | null | undefined)?],
+  Root,
+  string
+>
+export default remarkHtml
diff --git a/tools/ui/node_modules/remark-html/index.js b/tools/ui/node_modules/remark-html/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a4c25d60f746eac9b80f56076fa90be149881a2
--- /dev/null
+++ b/tools/ui/node_modules/remark-html/index.js
@@ -0,0 +1,2 @@
+// Note: types exposed from `index.d.ts`.
+export {default} from './lib/index.js'
diff --git a/tools/ui/node_modules/remark-html/lib/index.d.ts b/tools/ui/node_modules/remark-html/lib/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6edd8cf2bb46dd5c6af734580fe527e5325cbcfe
--- /dev/null
+++ b/tools/ui/node_modules/remark-html/lib/index.d.ts
@@ -0,0 +1,55 @@
+/**
+ * Serialize markdown as HTML.
+ *
+ * ###### Notes
+ *
+ * Passing `sanitize: false` is dangerous.
+ * It allows arbitrary HTML and does not sanitize elements.
+ *
+ * @param {Readonly | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function remarkHtml(options?: Readonly | null | undefined): undefined;
+export default class remarkHtml {
+    /**
+     * Serialize markdown as HTML.
+     *
+     * ###### Notes
+     *
+     * Passing `sanitize: false` is dangerous.
+     * It allows arbitrary HTML and does not sanitize elements.
+     *
+     * @param {Readonly | null | undefined} [options]
+     *   Configuration (optional).
+     * @returns {undefined}
+     *   Nothing.
+     */
+    constructor(options?: Readonly | null | undefined);
+    compiler: (tree: import("mdast").Root, file: import("vfile").VFile) => string;
+}
+export type Schema = import('hast-util-sanitize').Schema;
+export type ToHtmlOptions = import('hast-util-to-html').Options;
+export type Root = import('mdast').Root;
+export type Handlers = import('mdast-util-to-hast').Handlers;
+export type Compiler = import('unified').Compiler;
+export type Processor = import('unified').Processor;
+/**
+ * Extra fields.
+ */
+export type ExtraOptionsFields = {
+    /**
+     * How to turn mdast nodes into hast nodes (optional);
+     * passed to `mdast-util-to-hast`.
+     */
+    handlers?: Readonly | null | undefined;
+    /**
+     * Sanitize the output, and how (default: `true`).
+     */
+    sanitize?: Readonly | boolean | null | undefined;
+};
+/**
+ * Configuration.
+ */
+export type Options = ToHtmlOptions & ExtraOptionsFields;
diff --git a/tools/ui/node_modules/remark-html/lib/index.js b/tools/ui/node_modules/remark-html/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..a6bfd0f13256382557283a748b8554abbc3d463d
--- /dev/null
+++ b/tools/ui/node_modules/remark-html/lib/index.js
@@ -0,0 +1,81 @@
+/**
+ * @typedef {import('hast-util-sanitize').Schema} Schema
+ * @typedef {import('hast-util-to-html').Options} ToHtmlOptions
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('mdast-util-to-hast').Handlers} Handlers
+ * @typedef {import('unified').Compiler} Compiler
+ * @typedef {import('unified').Processor} Processor
+ */
+
+/**
+ * @typedef ExtraOptionsFields
+ *   Extra fields.
+ * @property {Readonly | null | undefined} [handlers]
+ *   How to turn mdast nodes into hast nodes (optional);
+ *   passed to `mdast-util-to-hast`.
+ * @property {Readonly | boolean | null | undefined} [sanitize]
+ *   Sanitize the output, and how (default: `true`).
+ *
+ * @typedef {ToHtmlOptions & ExtraOptionsFields} Options
+ *   Configuration.
+ */
+
+import {sanitize} from 'hast-util-sanitize'
+import {toHast} from 'mdast-util-to-hast'
+import {toHtml} from 'hast-util-to-html'
+
+/** @type {Readonly} */
+const emptyOptions = {}
+
+/**
+ * Serialize markdown as HTML.
+ *
+ * ###### Notes
+ *
+ * Passing `sanitize: false` is dangerous.
+ * It allows arbitrary HTML and does not sanitize elements.
+ *
+ * @param {Readonly | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function remarkHtml(options) {
+  /** @type {Processor} */
+  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.
+  // eslint-disable-next-line unicorn/no-this-assignment
+  const self = this
+  const {handlers, sanitize: clean, ...toHtmlOptions} = options || emptyOptions
+  let allowDangerousHtml = false
+  /** @type {Readonly | undefined} */
+  let schema
+
+  if (typeof clean === 'boolean') {
+    allowDangerousHtml = !clean
+  } else if (clean) {
+    schema = clean
+  }
+
+  self.compiler = compiler
+
+  /**
+   * @type {Compiler}
+   */
+  function compiler(tree, file) {
+    const hast = toHast(tree, {handlers, allowDangerousHtml})
+    const safeHast = allowDangerousHtml ? hast : sanitize(hast, schema)
+    const result = toHtml(safeHast, {...toHtmlOptions, allowDangerousHtml})
+
+    if (file.extname) {
+      file.extname = '.html'
+    }
+
+    // Add an eof eol.
+    return tree &&
+      tree.type === 'root' &&
+      result &&
+      /[^\r\n]/.test(result.charAt(result.length - 1))
+      ? result + '\n'
+      : result
+  }
+}
diff --git a/tools/ui/node_modules/remark-html/license b/tools/ui/node_modules/remark-html/license
new file mode 100644
index 0000000000000000000000000000000000000000..fbcbb18b93234c4240f895fe0db738df3bf5e523
--- /dev/null
+++ b/tools/ui/node_modules/remark-html/license
@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (c) 2015 Titus Wormer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/tools/ui/node_modules/remark-html/package.json b/tools/ui/node_modules/remark-html/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..430fdc5bea9cd1b22bff8b515547b2795b47d5bb
--- /dev/null
+++ b/tools/ui/node_modules/remark-html/package.json
@@ -0,0 +1,117 @@
+{
+  "name": "remark-html",
+  "version": "16.0.1",
+  "description": "remark plugin to compile Markdown to HTML",
+  "license": "MIT",
+  "keywords": [
+    "compile",
+    "html",
+    "markdown",
+    "mdast",
+    "plugin",
+    "remark",
+    "remark-plugin",
+    "stringify",
+    "unified"
+  ],
+  "repository": "remarkjs/remark-html",
+  "bugs": "https://github.com/remarkjs/remark-html/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Titus Wormer  (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer  (https://wooorm.com)",
+    "Ben Briggs ",
+    "Seth Vincent ",
+    "Junyoung Choi ",
+    "Jonathan Soeder "
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./index.js",
+  "files": [
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "@types/mdast": "^4.0.0",
+    "hast-util-sanitize": "^5.0.0",
+    "mdast-util-to-hast": "^13.0.0",
+    "hast-util-to-html": "^9.0.0",
+    "unified": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/hast": "^3.0.0",
+    "@types/node": "^20.0.0",
+    "c8": "^8.0.0",
+    "commonmark.json": "^0.30.0",
+    "hast-util-from-html": "^2.0.0",
+    "prettier": "^3.0.0",
+    "remark-cli": "^11.0.0",
+    "remark-frontmatter": "^5.0.0",
+    "remark-gfm": "^4.0.0",
+    "remark-github": "^12.0.0",
+    "remark-parse": "^11.0.0",
+    "remark-preset-wooorm": "^9.0.0",
+    "remark-slug": "^7.0.0",
+    "remark-toc": "^9.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^5.0.0",
+    "vfile": "^6.0.0",
+    "xo": "^0.56.0"
+  },
+  "scripts": {
+    "build": "tsc --build --clean && tsc --build && type-coverage",
+    "format": "remark . --frail --output --quiet && prettier . --log-level warn --write && xo --fix",
+    "prepack": "npm run build && npm run format",
+    "test": "npm run build && npm run format && npm run test-coverage",
+    "test-api": "node --conditions development test/index.js",
+    "test-coverage": "c8 --100 --reporter lcov npm run test-api"
+  },
+  "prettier": {
+    "bracketSpacing": false,
+    "singleQuote": true,
+    "semi": false,
+    "tabWidth": 2,
+    "trailingComma": "none",
+    "useTabs": false
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-wooorm"
+    ]
+  },
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "ignoreCatch": true,
+    "strict": true
+  },
+  "xo": {
+    "overrides": [
+      {
+        "files": [
+          "**/*.ts"
+        ],
+        "rules": {
+          "@typescript-eslint/ban-types": "off"
+        }
+      },
+      {
+        "files": [
+          "test/**/*.js"
+        ],
+        "rules": {
+          "no-await-in-loop": "off"
+        }
+      }
+    ],
+    "prettier": true,
+    "rules": {
+      "unicorn/prefer-at": "off"
+    }
+  }
+}
diff --git a/tools/ui/node_modules/remark-html/readme.md b/tools/ui/node_modules/remark-html/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..4f07173e45cf741eeac0367567376def91e00982
--- /dev/null
+++ b/tools/ui/node_modules/remark-html/readme.md
@@ -0,0 +1,286 @@
+# remark-html
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][sponsors-badge]][collective]
+[![Backers][backers-badge]][collective]
+[![Chat][chat-badge]][chat]
+
+**[remark][]** plugin to add support for serializing HTML.
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When should I use this?](#when-should-i-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+    *   [`unified().use(remarkHtml[, options])`](#unifieduseremarkhtml-options)
+    *   [`Options`](#options)
+*   [Types](#types)
+*   [Compatibility](#compatibility)
+*   [Security](#security)
+*   [Related](#related)
+*   [Contribute](#contribute)
+*   [License](#license)
+
+## What is this?
+
+This package is a [unified][] ([remark][]) plugin that compiles markdown to
+HTML.
+
+## When should I use this?
+
+This plugin is useful when you want to turn markdown into HTML.
+It’s a shortcut for
+`.use(remarkRehype).use(rehypeSanitize).use(rehypeStringify)`.
+
+The reason that there are different ecosystems for markdown and HTML is that
+turning markdown into HTML is, while frequently needed, not the only purpose of
+markdown.
+Checking (linting) and formatting markdown are also common use cases for
+remark and markdown.
+There are several aspects of markdown that do not translate 1-to-1 to HTML.
+In some cases markdown contains more information than HTML: for example, there
+are several ways to add a link in markdown (as in, autolinks: ``,
+resource links: `[label](url)`, and reference links with definitions:
+`[label][id]` and `[id]: url`).
+In other cases HTML contains more information than markdown: there are many
+tags, which add new meaning (semantics), available in HTML that aren’t available
+in markdown.
+If there was just one AST, it would be quite hard to perform the tasks that
+several remark and rehype plugins currently do.
+
+This plugin is useful when you want to quickly turn markdown into HTML.
+In most cases though, it’s recommended to use [`remark-rehype`][remark-rehype]
+instead and finally use [`rehype-stringify`][rehype-stringify] to serialize
+HTML.
+The reason using both ecosystems instead of this plugin is recommended, is that
+there are many useful rehype plugins that you can then use.
+For example, you can [minify HTML][rehype-minify], [format HTML][rehype-format],
+[highlight code][rehype-highlight], [add metadata][rehype-meta], and a lot more.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install remark-html
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import remarkHtml from 'https://esm.sh/remark-html@16'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+
+```
+
+## Use
+
+Say we have the following file `example.md`:
+
+```markdown
+# Pluto
+
+**Pluto** (minor-planet designation: **134340 Pluto**) is a
+[dwarf planet](https://en.wikipedia.org/wiki/Dwarf_planet) in the
+[Kuiper belt](https://en.wikipedia.org/wiki/Kuiper_belt).
+```
+
+…and a module `example.js`:
+
+```js
+import remarkHtml from 'remark-html'
+import remarkParse from 'remark-parse'
+import {read} from 'to-vfile'
+import {unified} from 'unified'
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkHtml)
+  .process(await read('example.md'))
+
+console.log(String(file))
+```
+
+…then running `node example.js` yields:
+
+```html
+
Pluto

+
Pluto (minor-planet designation: 134340 Pluto) is a
+dwarf planet in the
+Kuiper belt.

+```
+
+## API
+
+This package exports no identifiers.
+The default export is [`remarkHtml`][api-remark-html].
+
+### `unified().use(remarkHtml[, options])`
+
+Serialize markdown as HTML.
+
+###### Parameters
+
+*   `options` ([`Options`][api-options], optional)
+    — configuration
+
+###### Returns
+
+Transform ([`Transformer`][unified-transformer]).
+
+###### Notes
+
+Passing `sanitize: false` is dangerous.
+It allows arbitrary HTML and does not sanitize elements.
+
+### `Options`
+
+Configuration (TypeScript type).
+
+###### Fields
+
+*   `handlers` ([`Handlers` from
+    `mdast-util-to-hast`][mdast-util-to-hast-handlers], optional)
+    — how to turn mdast nodes into hast nodes
+*   `sanitize` ([`Schema` from
+    `hast-util-sanitize`][hast-util-sanitize-schema] or `boolean`, default:
+    `true`)
+    — sanitize the output, and how
+*   `...toHtmlOptions` ([`Options` from
+    `hast-util-to-html`][hast-util-to-html-options], optional)
+    — other options are passed to `hast-util-to-html`
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional type [`Options`][api-options].
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line, `remark-html@^16`,
+compatible with Node.js 16.
+
+This plugin works with `unified` version 6+ and `remark` version 15+.
+
+## Security
+
+Use of `remark-html` is safe by default.
+Passing `sanitize: false` is unsafe and opens you up to
+[cross-site scripting (XSS)][wiki-xss] attacks.
+A safe schema is used by default, but passing an unsafe schema is unsafe.
+
+## Related
+
+*   [`remark-rehype`](https://github.com/remarkjs/remark-rehype)
+    — turn markdown into HTML to support rehype
+*   [`rehype-sanitize`](https://github.com/rehypejs/rehype-sanitize)
+    — sanitize HTML
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`remarkjs/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+
+
+[build-badge]: https://github.com/remarkjs/remark-html/workflows/main/badge.svg
+
+[build]: https://github.com/remarkjs/remark-html/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/remarkjs/remark-html.svg
+
+[coverage]: https://codecov.io/github/remarkjs/remark-html
+
+[downloads-badge]: https://img.shields.io/npm/dm/remark-html.svg
+
+[downloads]: https://www.npmjs.com/package/remark-html
+
+[size-badge]: https://img.shields.io/bundlejs/size/remark-html
+
+[size]: https://bundlejs.com/?q=remark-html
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[collective]: https://opencollective.com/unified
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/remarkjs/remark/discussions
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[health]: https://github.com/remarkjs/.github
+
+[contributing]: https://github.com/remarkjs/.github/blob/main/contributing.md
+
+[support]: https://github.com/remarkjs/.github/blob/main/support.md
+
+[coc]: https://github.com/remarkjs/.github/blob/main/code-of-conduct.md
+
+[license]: license
+
+[author]: https://wooorm.com
+
+[hast-util-sanitize-schema]: https://github.com/syntax-tree/hast-util-sanitize#schema
+
+[hast-util-to-html-options]: https://github.com/syntax-tree/hast-util-to-html#options
+
+[mdast-util-to-hast-handlers]: https://github.com/syntax-tree/mdast-util-to-hast#handlers
+
+[rehype-format]: https://github.com/rehypejs/rehype-format
+
+[rehype-highlight]: https://github.com/rehypejs/rehype-highlight
+
+[rehype-meta]: https://github.com/rehypejs/rehype-meta
+
+[rehype-minify]: https://github.com/rehypejs/rehype-minify
+
+[rehype-stringify]: https://github.com/rehypejs/rehype/tree/main/packages/rehype-stringify
+
+[remark]: https://github.com/remarkjs/remark
+
+[remark-rehype]: https://github.com/remarkjs/remark-rehype
+
+[typescript]: https://www.typescriptlang.org
+
+[unified]: https://github.com/unifiedjs/unified
+
+[unified-transformer]: https://github.com/unifiedjs/unified#transformer
+
+[wiki-xss]: https://en.wikipedia.org/wiki/Cross-site_scripting
+
+[api-options]: #options
+
+[api-remark-html]: #unifieduseremarkhtml-options
diff --git a/tools/ui/node_modules/remark-math/index.d.ts b/tools/ui/node_modules/remark-math/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f0d11688a58890f1af53d70619842458d22b8367
--- /dev/null
+++ b/tools/ui/node_modules/remark-math/index.d.ts
@@ -0,0 +1,2 @@
+export { default } from "./lib/index.js";
+export type Options = import('./lib/index.js').Options;
diff --git a/tools/ui/node_modules/remark-math/index.js b/tools/ui/node_modules/remark-math/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..a49a278876feae34fbbafdc4ba522fd38143e99b
--- /dev/null
+++ b/tools/ui/node_modules/remark-math/index.js
@@ -0,0 +1,5 @@
+/**
+ * @typedef {import('./lib/index.js').Options} Options
+ */
+
+export {default} from './lib/index.js'
diff --git a/tools/ui/node_modules/remark-math/lib/index.d.ts b/tools/ui/node_modules/remark-math/lib/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fa6804bf369ab61c9327a31eb0040f544e8e6869
--- /dev/null
+++ b/tools/ui/node_modules/remark-math/lib/index.d.ts
@@ -0,0 +1,12 @@
+/**
+ * Add support for math.
+ *
+ * @param {Readonly | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function remarkMath(options?: Readonly | null | undefined): undefined;
+export type Root = import('mdast').Root;
+export type Options = import('mdast-util-math').ToOptions;
+export type Processor = import('unified').Processor;
diff --git a/tools/ui/node_modules/remark-math/lib/index.js b/tools/ui/node_modules/remark-math/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..48ae82d8cd531fa07d738e557701e81bc966566a
--- /dev/null
+++ b/tools/ui/node_modules/remark-math/lib/index.js
@@ -0,0 +1,42 @@
+/// 
+/// 
+/// 
+
+/**
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('mdast-util-math').ToOptions} Options
+ * @typedef {import('unified').Processor} Processor
+ */
+
+import {mathFromMarkdown, mathToMarkdown} from 'mdast-util-math'
+import {math} from 'micromark-extension-math'
+
+/** @type {Readonly} */
+const emptyOptions = {}
+
+/**
+ * Add support for math.
+ *
+ * @param {Readonly | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function remarkMath(options) {
+  // @ts-expect-error: TS is wrong about `this`.
+  // eslint-disable-next-line unicorn/no-this-assignment
+  const self = /** @type {Processor} */ (this)
+  const settings = options || emptyOptions
+  const data = self.data()
+
+  const micromarkExtensions =
+    data.micromarkExtensions || (data.micromarkExtensions = [])
+  const fromMarkdownExtensions =
+    data.fromMarkdownExtensions || (data.fromMarkdownExtensions = [])
+  const toMarkdownExtensions =
+    data.toMarkdownExtensions || (data.toMarkdownExtensions = [])
+
+  micromarkExtensions.push(math(settings))
+  fromMarkdownExtensions.push(mathFromMarkdown())
+  toMarkdownExtensions.push(mathToMarkdown(settings))
+}
diff --git a/tools/ui/node_modules/remark-math/package.json b/tools/ui/node_modules/remark-math/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..3fad47b0003dd54bbae2716811796adc6e4bf923
--- /dev/null
+++ b/tools/ui/node_modules/remark-math/package.json
@@ -0,0 +1,50 @@
+{
+  "name": "remark-math",
+  "version": "6.0.0",
+  "description": "remark plugin to parse and stringify math",
+  "license": "MIT",
+  "keywords": [
+    "katex",
+    "latex",
+    "markdown",
+    "math",
+    "mdast",
+    "plugin",
+    "remark",
+    "remark-plugin",
+    "tex",
+    "unified"
+  ],
+  "repository": "https://github.com/remarkjs/remark-math/tree/main/packages/remark-math",
+  "bugs": "https://github.com/remarkjs/remark-math/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Junyoung Choi  (https://rokt33r.github.io)",
+  "contributors": [
+    "Junyoung Choi  (https://rokt33r.github.io)",
+    "Titus Wormer  (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./index.js",
+  "files": [
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "@types/mdast": "^4.0.0",
+    "mdast-util-math": "^3.0.0",
+    "micromark-extension-math": "^3.0.0",
+    "unified": "^11.0.0"
+  },
+  "scripts": {
+    "test-api": "node --conditions development test.js",
+    "test": "npm run build && npm run test-api"
+  },
+  "xo": {
+    "prettier": true
+  }
+}
diff --git a/tools/ui/node_modules/remark-math/readme.md b/tools/ui/node_modules/remark-math/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..07504dece6692ad19f528701e2a176bb4b245731
--- /dev/null
+++ b/tools/ui/node_modules/remark-math/readme.md
@@ -0,0 +1,347 @@
+# remark-math
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][sponsors-badge]][collective]
+[![Backers][backers-badge]][collective]
+[![Chat][chat-badge]][chat]
+
+**[remark][]** plugin to support math (`$C_L$`).
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When should I use this?](#when-should-i-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+    *   [`unified().use(remarkMath[, options])`](#unifieduseremarkmath-options)
+    *   [`Options`](#options)
+*   [Authoring](#authoring)
+*   [HTML](#html)
+*   [CSS](#css)
+*   [Syntax](#syntax)
+*   [Syntax tree](#syntax-tree)
+*   [Types](#types)
+*   [Compatibility](#compatibility)
+*   [Security](#security)
+*   [Related](#related)
+*   [Contribute](#contribute)
+*   [License](#license)
+
+## What is this?
+
+This package is a [unified][] ([remark][]) plugin to add support for math
+syntax.
+You can use this to add support for parsing and serializing this syntax
+extension.
+
+As there is no spec for math in markdown, this extension follows how code
+(fenced and text) works in Commonmark, but uses dollars (`$`).
+
+## When should I use this?
+
+This project is useful when you want to support math in markdown.
+Extending markdown with a syntax extension makes the markdown less portable.
+LaTeX equations are also quite hard.
+But this mechanism works well when you want authors, that have some LaTeX
+experience, to be able to embed rich diagrams of math in scientific text.
+
+If you *just* want to turn markdown into HTML (with maybe a few extensions such
+as math), we recommend [`micromark`][micromark] with
+[`micromark-extension-math`][micromark-extension-math] instead.
+If you don’t use plugins and want to access the syntax tree, you can use
+[`mdast-util-from-markdown`][mdast-util-from-markdown] with
+[`mdast-util-math`][mdast-util-math].
+
+This plugins adds [fields on nodes][mdast-util-to-hast-fields] so that the
+plugin responsible for turning markdown (mdast) into HTML (hast),
+[`remark-rehype`][remark-rehype], will turn text math (inline) into
+`…` and flow math (block)
+into `
…
`.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install remark-math
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import remarkMath from 'https://esm.sh/remark-math@6'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+
+```
+
+## Use
+
+Say our document `example.md` contains:
+
+```markdown
+Lift($$L$$) can be determined by Lift Coefficient ($$C_L$$) like the following
+equation.
+
+$$
+L = \frac{1}{2} \rho v^2 S C_L
+$$
+```
+
+…and our module `example.js` contains:
+
+```js
+import rehypeKatex from 'rehype-katex'
+import rehypeStringify from 'rehype-stringify'
+import remarkMath from 'remark-math'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import {read} from 'to-vfile'
+import {unified} from 'unified'
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkMath)
+  .use(remarkRehype)
+  .use(rehypeKatex)
+  .use(rehypeStringify)
+  .process(await read('example.md'))
+
+console.log(String(file))
+```
+
+…then running `node example.js` yields:
+
+```html
+
Lift(…) like the following
+equation.

+
…

+```
+
+## API
+
+This package exports no identifiers.
+The default export is [`remarkMath`][api-remark-math].
+
+### `unified().use(remarkMath[, options])`
+
+Add support for math.
+
+###### Parameters
+
+*   `options` ([`Options`][api-options], optional)
+    — configuration
+
+###### Returns
+
+Nothing (`undefined`).
+
+### `Options`
+
+Configuration (TypeScript type).
+
+###### Fields
+
+*   `singleDollarTextMath` (`boolean`, default: `true`)
+    — whether to support text math (inline) with a single dollar.
+    Single dollars work in Pandoc and many other places, but often interfere
+    with “normal” dollars in text.
+    If you turn this off, you can still use two or more dollars for text math.
+
+## Authoring
+
+When authoring markdown with math, keep in mind that math doesn’t work in most
+places.
+Notably, GitHub currently has a really weird crappy client-side regex-based
+thing.
+But on your own (math-heavy?) site it can be great!
+
+Instead of a syntax extension to markdown, you can also use fenced code with an
+info string of `math`:
+
+````markdown
+```math
+L = \frac{1}{2} \rho v^2 S C_L
+```
+````
+
+## HTML
+
+This plugin integrates with [`remark-rehype`][remark-rehype].
+When markdown (mdast) is turned into HTML (hast) the math nodes are turned
+into `…` and
+`
…
` elements.
+
+## CSS
+
+This package does not relate to CSS.
+You can choose to render the math with KaTeX, MathJax, or something else, which
+might need CSS.
+
+## Syntax
+
+See [*Syntax* in
+`micromark-extension-math`](https://github.com/micromark/micromark-extension-math#syntax).
+
+## Syntax tree
+
+See [*Syntax tree* in
+`mdast-util-math`](https://github.com/syntax-tree/mdast-util-math#syntax-tree).
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional type [`Options`][api-options].
+
+If you’re working with the syntax tree, you can register the new node types
+with `@types/mdast` by adding a reference:
+
+```js
+// Register math nodes in mdast:
+/// 
+
+import {visit} from 'unist-util-visit'
+
+function myRemarkPlugin() {
+  /**
+   * @param {import('mdast').Root} tree
+   *   Tree.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  return function (tree) {
+    visit(tree, function (node) {
+      console.log(node) // `node` can now be one of the math nodes.
+    })
+  }
+}
+```
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line, `remark-math@^6`,
+compatible with Node.js 16.
+
+This plugin works with unified version 6+ and remark version 14+.
+The previous major (version 4) worked with remark 13.
+
+## Security
+
+Use of `remark-math` does not involve **[rehype][]** ([hast][]) or user
+content so there are no openings for [cross-site scripting (XSS)][wiki-xss]
+attacks.
+
+## Related
+
+*   [`remark-gfm`](https://github.com/remarkjs/remark-gfm)
+    — support GFM (autolink literals, footnotes, strikethrough, tables,
+    tasklists)
+*   [`remark-frontmatter`](https://github.com/remarkjs/remark-frontmatter)
+    — support frontmatter (YAML, TOML, and more)
+*   [`remark-directive`](https://github.com/remarkjs/remark-directive)
+    — support directives
+*   [`remark-mdx`](https://github.com/mdx-js/mdx/tree/main/packages/remark-mdx)
+    — support MDX (ESM, JSX, expressions)
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`remarkjs/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Junyoung Choi][author]
+
+
+
+[build-badge]: https://github.com/remarkjs/remark-math/workflows/main/badge.svg
+
+[build]: https://github.com/remarkjs/remark-math/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/remarkjs/remark-math.svg
+
+[coverage]: https://codecov.io/github/remarkjs/remark-math
+
+[downloads-badge]: https://img.shields.io/npm/dm/remark-math.svg
+
+[downloads]: https://www.npmjs.com/package/remark-math
+
+[size-badge]: https://img.shields.io/bundlejs/size/remark-math
+
+[size]: https://bundlejs.com/?q=remark-math
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[collective]: https://opencollective.com/unified
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/remarkjs/remark/discussions
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[health]: https://github.com/remarkjs/.github
+
+[contributing]: https://github.com/remarkjs/.github/blob/main/contributing.md
+
+[support]: https://github.com/remarkjs/.github/blob/main/support.md
+
+[coc]: https://github.com/remarkjs/.github/blob/main/code-of-conduct.md
+
+[license]: https://github.com/remarkjs/remark-math/blob/main/license
+
+[author]: https://rokt33r.github.io
+
+[hast]: https://github.com/syntax-tree/hast
+
+[mdast-util-from-markdown]: https://github.com/syntax-tree/mdast-util-from-markdown
+
+[mdast-util-math]: https://github.com/syntax-tree/mdast-util-math
+
+[mdast-util-to-hast-fields]: https://github.com/syntax-tree/mdast-util-to-hast#fields-on-nodes
+
+[micromark]: https://github.com/micromark/micromark
+
+[micromark-extension-math]: https://github.com/micromark/micromark-extension-math
+
+[rehype]: https://github.com/rehypejs/rehype
+
+[remark]: https://github.com/remarkjs/remark
+
+[remark-rehype]: https://github.com/remarkjs/remark-rehype
+
+[typescript]: https://www.typescriptlang.org
+
+[unified]: https://github.com/unifiedjs/unified
+
+[wiki-xss]: https://en.wikipedia.org/wiki/Cross-site_scripting
+
+[api-options]: #options
+
+[api-remark-math]: #unifieduseremarkmath-options
diff --git a/tools/ui/node_modules/remark-parse/index.d.ts b/tools/ui/node_modules/remark-parse/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c74ec6563cef8a0eef2ea1ab2d9fc8a3f8ab5b5f
--- /dev/null
+++ b/tools/ui/node_modules/remark-parse/index.d.ts
@@ -0,0 +1,55 @@
+import type {Root} from 'mdast'
+import type {Extension as FromMarkdownExtension} from 'mdast-util-from-markdown'
+import type {Extension as MicromarkExtension} from 'micromark-util-types'
+import type {Plugin} from 'unified'
+import type {Options} from './lib/index.js'
+
+export type {Options} from './lib/index.js'
+
+/**
+ * Add support for parsing from markdown.
+ *
+ * @this
+ *   Unified processor.
+ * @param
+ *   Configuration (optional).
+ * @returns
+ *   Nothing.
+ */
+declare const remarkParse: Plugin<
+  [(Readonly | null | undefined)?],
+  string,
+  Root
+>
+export default remarkParse
+
+// Add custom settings supported when `remark-parse` is added.
+declare module 'unified' {
+  interface Settings extends Options {}
+
+  interface Data {
+    /**
+     * List of `micromark` extensions to use.
+     *
+     * This type is registered by `remark-parse`.
+     * Values can be registered by remark plugins that extend `micromark` and
+     * `mdast-util-from-markdown`.
+     * See {@link MicromarkExtension | `Extension`} from
+     * {@link https://github.com/micromark/micromark/tree/main/packages/micromark-util-types | `micromark-util-types`}.
+     */
+    micromarkExtensions?: MicromarkExtension[]
+
+    /**
+     * List of `mdast-util-from-markdown` extensions to use.
+     *
+     * This type is registered by `remark-parse`.
+     * Values can be registered by remark plugins that extend `micromark` and
+     * `mdast-util-from-markdown`.
+     * See {@link FromMarkdownExtension | `Extension`} from
+     * {@link https://github.com/syntax-tree/mdast-util-from-markdown#extension | `mdast-util-from-markdown`}.
+     */
+    fromMarkdownExtensions?: Array<
+      FromMarkdownExtension[] | FromMarkdownExtension
+    >
+  }
+}
diff --git a/tools/ui/node_modules/remark-parse/index.js b/tools/ui/node_modules/remark-parse/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a4c25d60f746eac9b80f56076fa90be149881a2
--- /dev/null
+++ b/tools/ui/node_modules/remark-parse/index.js
@@ -0,0 +1,2 @@
+// Note: types exposed from `index.d.ts`.
+export {default} from './lib/index.js'
diff --git a/tools/ui/node_modules/remark-parse/lib/index.d.ts b/tools/ui/node_modules/remark-parse/lib/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c63d18f01743e81a99da48b3aea154c21ee900a8
--- /dev/null
+++ b/tools/ui/node_modules/remark-parse/lib/index.d.ts
@@ -0,0 +1,26 @@
+/**
+ * Aadd support for parsing from markdown.
+ *
+ * @param {Readonly | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function remarkParse(options?: Readonly | null | undefined): undefined;
+export default class remarkParse {
+    /**
+     * Aadd support for parsing from markdown.
+     *
+     * @param {Readonly | null | undefined} [options]
+     *   Configuration (optional).
+     * @returns {undefined}
+     *   Nothing.
+     */
+    constructor(options?: Readonly | null | undefined);
+    parser: (document: string, file: import("vfile").VFile) => import("mdast").Root;
+}
+export type Root = import('mdast').Root;
+export type FromMarkdownOptions = import('mdast-util-from-markdown').Options;
+export type Parser = import('unified').Parser;
+export type Processor = import('unified').Processor;
+export type Options = Omit;
diff --git a/tools/ui/node_modules/remark-parse/lib/index.js b/tools/ui/node_modules/remark-parse/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..f4edbf33c9207074c8c838232c52f1b43fcf3733
--- /dev/null
+++ b/tools/ui/node_modules/remark-parse/lib/index.js
@@ -0,0 +1,43 @@
+/**
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('mdast-util-from-markdown').Options} FromMarkdownOptions
+ * @typedef {import('unified').Parser} Parser
+ * @typedef {import('unified').Processor} Processor
+ */
+
+/**
+ * @typedef {Omit} Options
+ */
+
+import {fromMarkdown} from 'mdast-util-from-markdown'
+
+/**
+ * Aadd support for parsing from markdown.
+ *
+ * @param {Readonly | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function remarkParse(options) {
+  /** @type {Processor} */
+  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.
+  const self = this
+
+  self.parser = parser
+
+  /**
+   * @type {Parser}
+   */
+  function parser(doc) {
+    return fromMarkdown(doc, {
+      ...self.data('settings'),
+      ...options,
+      // Note: these options are not in the readme.
+      // The goal is for them to be set by plugins on `data` instead of being
+      // passed by users.
+      extensions: self.data('micromarkExtensions') || [],
+      mdastExtensions: self.data('fromMarkdownExtensions') || []
+    })
+  }
+}
diff --git a/tools/ui/node_modules/remark-parse/license b/tools/ui/node_modules/remark-parse/license
new file mode 100644
index 0000000000000000000000000000000000000000..51b543068c8c0ddf05a0c35563fcfff5f6c16f8e
--- /dev/null
+++ b/tools/ui/node_modules/remark-parse/license
@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (c) 2014 Titus Wormer 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/tools/ui/node_modules/remark-parse/package.json b/tools/ui/node_modules/remark-parse/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..8383b21b8271a149fa95c5b75f4198d863e9db6f
--- /dev/null
+++ b/tools/ui/node_modules/remark-parse/package.json
@@ -0,0 +1,72 @@
+{
+  "name": "remark-parse",
+  "version": "11.0.0",
+  "description": "remark plugin to add support for parsing markdown input",
+  "license": "MIT",
+  "keywords": [
+    "abstract",
+    "ast",
+    "markdown",
+    "mdast",
+    "parse",
+    "plugin",
+    "remark",
+    "remark-plugin",
+    "syntax",
+    "tree",
+    "unified"
+  ],
+  "homepage": "https://remark.js.org",
+  "repository": "https://github.com/remarkjs/remark/tree/main/packages/remark-parse",
+  "bugs": "https://github.com/remarkjs/remark/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Titus Wormer  (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer  (https://wooorm.com)",
+    "Eugene Sharygin ",
+    "Junyoung Choi ",
+    "Elijah Hamovitz ",
+    "Ika "
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./index.js",
+  "files": [
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "@types/mdast": "^4.0.0",
+    "mdast-util-from-markdown": "^2.0.0",
+    "micromark-util-types": "^2.0.0",
+    "unified": "^11.0.0"
+  },
+  "scripts": {},
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "ignoreCatch": true,
+    "strict": true
+  },
+  "xo": {
+    "overrides": [
+      {
+        "files": [
+          "**/*.ts"
+        ],
+        "rules": {
+          "@typescript-eslint/ban-types": "off",
+          "@typescript-eslint/consistent-type-definitions": "off"
+        }
+      }
+    ],
+    "prettier": true,
+    "rules": {
+      "unicorn/no-this-assignment": "off"
+    }
+  }
+}
diff --git a/tools/ui/node_modules/remark-parse/readme.md b/tools/ui/node_modules/remark-parse/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..b0977ab5763064b8bb22c1e91d47b169bbb5b410
--- /dev/null
+++ b/tools/ui/node_modules/remark-parse/readme.md
@@ -0,0 +1,428 @@
+# remark-parse
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][sponsors-badge]][collective]
+[![Backers][backers-badge]][collective]
+[![Chat][chat-badge]][chat]
+
+**[remark][]** plugin to add support for parsing from markdown.
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When should I use this?](#when-should-i-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+    *   [`unified().use(remarkParse)`](#unifieduseremarkparse)
+*   [Examples](#examples)
+    *   [Example: support GFM and frontmatter](#example-support-gfm-and-frontmatter)
+    *   [Example: turning markdown into a man page](#example-turning-markdown-into-a-man-page)
+*   [Syntax](#syntax)
+*   [Syntax tree](#syntax-tree)
+*   [Types](#types)
+*   [Compatibility](#compatibility)
+*   [Security](#security)
+*   [Contribute](#contribute)
+*   [Sponsor](#sponsor)
+*   [License](#license)
+
+## What is this?
+
+This package is a [unified][] ([remark][]) plugin that defines how to take
+markdown as input and turn it into a syntax tree.
+
+See [the monorepo readme][remark] for info on what the remark ecosystem is.
+
+## When should I use this?
+
+This plugin adds support to unified for parsing markdown.
+If you also need to serialize markdown, you can alternatively use
+[`remark`][remark-core], which combines unified, this plugin, and
+[`remark-stringify`][remark-stringify].
+
+If you *just* want to turn markdown into HTML (with maybe a few extensions),
+we recommend [`micromark`][micromark] instead.
+If you don’t use plugins and want to access the syntax tree, you can directly
+use [`mdast-util-from-markdown`][mdast-util-from-markdown].
+remark focusses on making it easier to transform content by abstracting these
+internals away.
+
+You can combine this plugin with other plugins to add syntax extensions.
+Notable examples that deeply integrate with it are
+[`remark-gfm`][remark-gfm],
+[`remark-mdx`][remark-mdx],
+[`remark-frontmatter`][remark-frontmatter],
+[`remark-math`][remark-math], and
+[`remark-directive`][remark-directive].
+You can also use any other [remark plugin][remark-plugin] after `remark-parse`.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install remark-parse
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import remarkParse from 'https://esm.sh/remark-parse@11'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+
+```
+
+## Use
+
+Say we have the following module `example.js`:
+
+```js
+import rehypeStringify from 'rehype-stringify'
+import remarkGfm from 'remark-gfm'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import {unified} from 'unified'
+
+const doc = `
+# Mercury
+
+**Mercury** is the first planet from the [Sun](https://en.wikipedia.org/wiki/Sun)
+and the smallest planet in the Solar System.
+`
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkGfm)
+  .use(remarkRehype)
+  .use(rehypeStringify)
+  .process(doc)
+
+console.log(String(file))
+```
+
+…then running `node example.js` yields:
+
+```html
+
Mercury

+
Mercury is the first planet from the Sun
+and the smallest planet in the Solar System.

+```
+
+## API
+
+This package exports no identifiers.
+The default export is [`remarkParse`][api-remark-parse].
+
+### `unified().use(remarkParse)`
+
+Add support for parsing from markdown.
+
+###### Parameters
+
+There are no parameters.
+
+###### Returns
+
+Nothing (`undefined`).
+
+## Examples
+
+### Example: support GFM and frontmatter
+
+We support CommonMark by default.
+Non-standard markdown extensions can be enabled with plugins.
+
+This example shows how to support GFM features (autolink literals,
+footnotes, strikethrough, tables, tasklists) and frontmatter (YAML):
+
+```js
+import rehypeStringify from 'rehype-stringify'
+import remarkFrontmatter from 'remark-frontmatter'
+import remarkGfm from 'remark-gfm'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import {unified} from 'unified'
+
+const doc = `---
+layout: solar-system
+---
+
+# Hi ~~Mars~~Venus!
+`
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkFrontmatter)
+  .use(remarkGfm)
+  .use(remarkRehype)
+  .use(rehypeStringify)
+  .process(doc)
+
+console.log(String(file))
+```
+
+Yields:
+
+```html
+
Hi MarsVenus!

+```
+
+### Example: turning markdown into a man page
+
+Man pages (short for manual pages) are a way to document CLIs (example: type
+`man git-log` in your terminal).
+They use an old markup format called roff.
+There’s a remark plugin, [`remark-man`][remark-man], that can serialize as
+roff.
+
+This example shows how to turn markdown into man pages by using unified with
+`remark-parse` and `remark-man`:
+
+```js
+import remarkMan from 'remark-man'
+import remarkParse from 'remark-parse'
+import {unified} from 'unified'
+
+const doc = `
+# titan(7) -- largest moon of saturn
+
+Titan is the largest moon…
+`
+
+const file = await unified().use(remarkParse).use(remarkMan).process(doc)
+
+console.log(String(file))
+```
+
+Yields:
+
+```roff
+.TH "TITAN" "7" "September 2023" "" ""
+.SH "NAME"
+\fBtitan\fR - largest moon of saturn
+.P
+Titan is the largest moon…
+```
+
+## Syntax
+
+Markdown is parsed according to CommonMark.
+Other plugins can add support for syntax extensions.
+If you’re interested in extending markdown,
+[more information is available in micromark’s readme][micromark-extend].
+
+## Syntax tree
+
+The syntax tree used in remark is [mdast][].
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional type `Options` (which is currently empty).
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line, `remark-parse@^11`,
+compatible with Node.js 16.
+
+## Security
+
+As markdown can be turned into HTML and improper use of HTML can open you up to
+[cross-site scripting (XSS)][xss] attacks, use of remark can be unsafe.
+When going to HTML, you will combine remark with **[rehype][]**, in which case
+you should use [`rehype-sanitize`][rehype-sanitize].
+
+Use of remark plugins could also open you up to other attacks.
+Carefully assess each plugin and the risks involved in using them.
+
+For info on how to submit a report, see our [security policy][security].
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`remarkjs/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+Join us in [Discussions][chat] to chat with the community and contributors.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## Sponsor
+
+Support this effort and give back by sponsoring on [OpenCollective][collective]!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+  Vercel


+  
+		
+  Motif


+  
+		
+  HashiCorp


+  
+		
+  GitBook


+  
+		
+  Gatsby


+  
+

+  Netlify


+  
+  
+		
+  Coinbase


+  
+		
+  ThemeIsle


+  
+		
+  Expo


+  
+		
+  Boost Note


+  
+		
+  Markdown Space


+  
+		
+  Holloway


+  
+

+  

+  You?
+  


+

+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+
+
+[build-badge]: https://github.com/remarkjs/remark/workflows/main/badge.svg
+
+[build]: https://github.com/remarkjs/remark/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/remarkjs/remark.svg
+
+[coverage]: https://codecov.io/github/remarkjs/remark
+
+[downloads-badge]: https://img.shields.io/npm/dm/remark-parse.svg
+
+[downloads]: https://www.npmjs.com/package/remark-parse
+
+[size-badge]: https://img.shields.io/bundlejs/size/remark-parse
+
+[size]: https://bundlejs.com/?q=remark-parse
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[collective]: https://opencollective.com/unified
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/remarkjs/remark/discussions
+
+[security]: https://github.com/remarkjs/.github/blob/main/security.md
+
+[health]: https://github.com/remarkjs/.github
+
+[contributing]: https://github.com/remarkjs/.github/blob/main/contributing.md
+
+[support]: https://github.com/remarkjs/.github/blob/main/support.md
+
+[coc]: https://github.com/remarkjs/.github/blob/main/code-of-conduct.md
+
+[license]: https://github.com/remarkjs/remark/blob/main/license
+
+[author]: https://wooorm.com
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[mdast]: https://github.com/syntax-tree/mdast
+
+[mdast-util-from-markdown]: https://github.com/syntax-tree/mdast-util-from-markdown
+
+[micromark]: https://github.com/micromark/micromark
+
+[micromark-extend]: https://github.com/micromark/micromark#extensions
+
+[rehype]: https://github.com/rehypejs/rehype
+
+[rehype-sanitize]: https://github.com/rehypejs/rehype-sanitize
+
+[remark]: https://github.com/remarkjs/remark
+
+[remark-core]: ../remark/
+
+[remark-directive]: https://github.com/remarkjs/remark-directive
+
+[remark-frontmatter]: https://github.com/remarkjs/remark-frontmatter
+
+[remark-gfm]: https://github.com/remarkjs/remark-gfm
+
+[remark-mdx]: https://github.com/mdx-js/mdx/tree/main/packages/remark-mdx
+
+[remark-man]: https://github.com/remarkjs/remark-man
+
+[remark-math]: https://github.com/remarkjs/remark-math
+
+[remark-plugin]: https://github.com/remarkjs/remark#plugin
+
+[remark-stringify]: ../remark-stringify/
+
+[typescript]: https://www.typescriptlang.org
+
+[unified]: https://github.com/unifiedjs/unified
+
+[xss]: https://en.wikipedia.org/wiki/Cross-site_scripting
+
+[api-remark-parse]: #unifieduseremarkparse
diff --git a/tools/ui/node_modules/remark-rehype/index.d.ts b/tools/ui/node_modules/remark-rehype/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d493d939e716bdeee6ef9d23ecc2f588fac5e812
--- /dev/null
+++ b/tools/ui/node_modules/remark-rehype/index.d.ts
@@ -0,0 +1,4 @@
+export { default } from "./lib/index.js";
+export type Options = import("./lib/index.js").Options;
+export { defaultFootnoteBackContent, defaultFootnoteBackLabel, defaultHandlers } from "mdast-util-to-hast";
+//# sourceMappingURL=index.d.ts.map
\ No newline at end of file
diff --git a/tools/ui/node_modules/remark-rehype/index.d.ts.map b/tools/ui/node_modules/remark-rehype/index.d.ts.map
new file mode 100644
index 0000000000000000000000000000000000000000..43cfb3e485027272ce4acbecfe05234a90659d31
--- /dev/null
+++ b/tools/ui/node_modules/remark-rehype/index.d.ts.map
@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":";sBACa,OAAO,gBAAgB,EAAE,OAAO"}
\ No newline at end of file
diff --git a/tools/ui/node_modules/remark-rehype/index.js b/tools/ui/node_modules/remark-rehype/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..c574dd0fa754d0c4e8ce113519e1777635608025
--- /dev/null
+++ b/tools/ui/node_modules/remark-rehype/index.js
@@ -0,0 +1,10 @@
+/**
+ * @typedef {import('./lib/index.js').Options} Options
+ */
+
+export {
+  defaultFootnoteBackContent,
+  defaultFootnoteBackLabel,
+  defaultHandlers
+} from 'mdast-util-to-hast'
+export {default} from './lib/index.js'
diff --git a/tools/ui/node_modules/remark-rehype/lib/index.d.ts b/tools/ui/node_modules/remark-rehype/lib/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bdb1928940aa500b4c9c0e5846d6b8daad5bdc58
--- /dev/null
+++ b/tools/ui/node_modules/remark-rehype/lib/index.d.ts
@@ -0,0 +1,353 @@
+/**
+ * Turn markdown into HTML.
+ *
+ * ##### Notes
+ *
+ * ###### Signature
+ *
+ * * if a processor is given,
+ *   runs the (rehype) plugins used on it with a hast tree,
+ *   then discards the result (*bridge mode*)
+ * * otherwise,
+ *   returns a hast tree,
+ *   the plugins used after `remarkRehype` are rehype plugins (*mutate mode*)
+ *
+ * > 👉 **Note**:
+ * > It’s highly unlikely that you want to pass a `processor`.
+ *
+ * ###### HTML
+ *
+ * Raw HTML is available in mdast as `html` nodes and can be embedded in hast
+ * as semistandard `raw` nodes.
+ * Most plugins ignore `raw` nodes but two notable ones don’t:
+ *
+ * * `rehype-stringify` also has an option `allowDangerousHtml` which will
+ *   output the raw HTML.
+ *   This is typically discouraged as noted by the option name but is useful if
+ *   you completely trust authors
+ * * `rehype-raw` can handle the raw embedded HTML strings by parsing them
+ *   into standard hast nodes (`element`, `text`, etc);
+ *   this is a heavy task as it needs a full HTML parser,
+ *   but it is the only way to support untrusted content
+ *
+ * ###### Footnotes
+ *
+ * Many options supported here relate to footnotes.
+ * Footnotes are not specified by CommonMark,
+ * which we follow by default.
+ * They are supported by GitHub,
+ * so footnotes can be enabled in markdown with `remark-gfm`.
+ *
+ * The options `footnoteBackLabel` and `footnoteLabel` define natural language
+ * that explains footnotes,
+ * which is hidden for sighted users but shown to assistive technology.
+ * When your page is not in English,
+ * you must define translated values.
+ *
+ * Back references use ARIA attributes,
+ * but the section label itself uses a heading that is hidden with an
+ * `sr-only` class.
+ * To show it to sighted users,
+ * define different attributes in `footnoteLabelProperties`.
+ *
+ * ###### Clobbering
+ *
+ * Footnotes introduces a problem,
+ * as it links footnote calls to footnote definitions on the page through `id`
+ * attributes generated from user content,
+ * which results in DOM clobbering.
+ *
+ * DOM clobbering is this:
+ *
+ * ```html
+ * 

+ * 
+ * ```
+ *
+ * Elements by their ID are made available by browsers on the `window` object,
+ * which is a security risk.
+ * Using a prefix solves this problem.
+ *
+ * More information on how to handle clobbering and the prefix is explained in
+ * *Example: headings (DOM clobbering)* in `rehype-sanitize`.
+ *
+ * ###### Unknown nodes
+ *
+ * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.
+ * The default behavior for unknown nodes is:
+ *
+ * * when the node has a `value`
+ *   (and doesn’t have `data.hName`, `data.hProperties`, or `data.hChildren`,
+ *   see later),
+ *   create a hast `text` node
+ * * otherwise,
+ *   create a `
` element (which could be changed with `data.hName`),
+ *   with its children mapped from mdast to hast as well
+ *
+ * This behavior can be changed by passing an `unknownHandler`.
+ *
+ * @overload
+ * @param {Processor} processor
+ * @param {Readonly | null | undefined} [options]
+ * @returns {TransformBridge}
+ *
+ * @overload
+ * @param {Readonly | null | undefined} [options]
+ * @returns {TransformMutate}
+ *
+ * @overload
+ * @param {Readonly | Processor | null | undefined} [destination]
+ * @param {Readonly | null | undefined} [options]
+ * @returns {TransformBridge | TransformMutate}
+ *
+ * @param {Readonly | Processor | null | undefined} [destination]
+ *   Processor or configuration (optional).
+ * @param {Readonly | null | undefined} [options]
+ *   When a processor was given,
+ *   configuration (optional).
+ * @returns {TransformBridge | TransformMutate}
+ *   Transform.
+ */
+export default function remarkRehype(processor: Processor, options?: Readonly | null | undefined): TransformBridge;
+/**
+ * Turn markdown into HTML.
+ *
+ * ##### Notes
+ *
+ * ###### Signature
+ *
+ * * if a processor is given,
+ *   runs the (rehype) plugins used on it with a hast tree,
+ *   then discards the result (*bridge mode*)
+ * * otherwise,
+ *   returns a hast tree,
+ *   the plugins used after `remarkRehype` are rehype plugins (*mutate mode*)
+ *
+ * > 👉 **Note**:
+ * > It’s highly unlikely that you want to pass a `processor`.
+ *
+ * ###### HTML
+ *
+ * Raw HTML is available in mdast as `html` nodes and can be embedded in hast
+ * as semistandard `raw` nodes.
+ * Most plugins ignore `raw` nodes but two notable ones don’t:
+ *
+ * * `rehype-stringify` also has an option `allowDangerousHtml` which will
+ *   output the raw HTML.
+ *   This is typically discouraged as noted by the option name but is useful if
+ *   you completely trust authors
+ * * `rehype-raw` can handle the raw embedded HTML strings by parsing them
+ *   into standard hast nodes (`element`, `text`, etc);
+ *   this is a heavy task as it needs a full HTML parser,
+ *   but it is the only way to support untrusted content
+ *
+ * ###### Footnotes
+ *
+ * Many options supported here relate to footnotes.
+ * Footnotes are not specified by CommonMark,
+ * which we follow by default.
+ * They are supported by GitHub,
+ * so footnotes can be enabled in markdown with `remark-gfm`.
+ *
+ * The options `footnoteBackLabel` and `footnoteLabel` define natural language
+ * that explains footnotes,
+ * which is hidden for sighted users but shown to assistive technology.
+ * When your page is not in English,
+ * you must define translated values.
+ *
+ * Back references use ARIA attributes,
+ * but the section label itself uses a heading that is hidden with an
+ * `sr-only` class.
+ * To show it to sighted users,
+ * define different attributes in `footnoteLabelProperties`.
+ *
+ * ###### Clobbering
+ *
+ * Footnotes introduces a problem,
+ * as it links footnote calls to footnote definitions on the page through `id`
+ * attributes generated from user content,
+ * which results in DOM clobbering.
+ *
+ * DOM clobbering is this:
+ *
+ * ```html
+ * 

+ * 
+ * ```
+ *
+ * Elements by their ID are made available by browsers on the `window` object,
+ * which is a security risk.
+ * Using a prefix solves this problem.
+ *
+ * More information on how to handle clobbering and the prefix is explained in
+ * *Example: headings (DOM clobbering)* in `rehype-sanitize`.
+ *
+ * ###### Unknown nodes
+ *
+ * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.
+ * The default behavior for unknown nodes is:
+ *
+ * * when the node has a `value`
+ *   (and doesn’t have `data.hName`, `data.hProperties`, or `data.hChildren`,
+ *   see later),
+ *   create a hast `text` node
+ * * otherwise,
+ *   create a `
` element (which could be changed with `data.hName`),
+ *   with its children mapped from mdast to hast as well
+ *
+ * This behavior can be changed by passing an `unknownHandler`.
+ *
+ * @overload
+ * @param {Processor} processor
+ * @param {Readonly | null | undefined} [options]
+ * @returns {TransformBridge}
+ *
+ * @overload
+ * @param {Readonly | null | undefined} [options]
+ * @returns {TransformMutate}
+ *
+ * @overload
+ * @param {Readonly | Processor | null | undefined} [destination]
+ * @param {Readonly | null | undefined} [options]
+ * @returns {TransformBridge | TransformMutate}
+ *
+ * @param {Readonly | Processor | null | undefined} [destination]
+ *   Processor or configuration (optional).
+ * @param {Readonly | null | undefined} [options]
+ *   When a processor was given,
+ *   configuration (optional).
+ * @returns {TransformBridge | TransformMutate}
+ *   Transform.
+ */
+export default function remarkRehype(options?: Readonly | null | undefined): TransformMutate;
+/**
+ * Turn markdown into HTML.
+ *
+ * ##### Notes
+ *
+ * ###### Signature
+ *
+ * * if a processor is given,
+ *   runs the (rehype) plugins used on it with a hast tree,
+ *   then discards the result (*bridge mode*)
+ * * otherwise,
+ *   returns a hast tree,
+ *   the plugins used after `remarkRehype` are rehype plugins (*mutate mode*)
+ *
+ * > 👉 **Note**:
+ * > It’s highly unlikely that you want to pass a `processor`.
+ *
+ * ###### HTML
+ *
+ * Raw HTML is available in mdast as `html` nodes and can be embedded in hast
+ * as semistandard `raw` nodes.
+ * Most plugins ignore `raw` nodes but two notable ones don’t:
+ *
+ * * `rehype-stringify` also has an option `allowDangerousHtml` which will
+ *   output the raw HTML.
+ *   This is typically discouraged as noted by the option name but is useful if
+ *   you completely trust authors
+ * * `rehype-raw` can handle the raw embedded HTML strings by parsing them
+ *   into standard hast nodes (`element`, `text`, etc);
+ *   this is a heavy task as it needs a full HTML parser,
+ *   but it is the only way to support untrusted content
+ *
+ * ###### Footnotes
+ *
+ * Many options supported here relate to footnotes.
+ * Footnotes are not specified by CommonMark,
+ * which we follow by default.
+ * They are supported by GitHub,
+ * so footnotes can be enabled in markdown with `remark-gfm`.
+ *
+ * The options `footnoteBackLabel` and `footnoteLabel` define natural language
+ * that explains footnotes,
+ * which is hidden for sighted users but shown to assistive technology.
+ * When your page is not in English,
+ * you must define translated values.
+ *
+ * Back references use ARIA attributes,
+ * but the section label itself uses a heading that is hidden with an
+ * `sr-only` class.
+ * To show it to sighted users,
+ * define different attributes in `footnoteLabelProperties`.
+ *
+ * ###### Clobbering
+ *
+ * Footnotes introduces a problem,
+ * as it links footnote calls to footnote definitions on the page through `id`
+ * attributes generated from user content,
+ * which results in DOM clobbering.
+ *
+ * DOM clobbering is this:
+ *
+ * ```html
+ * 

+ * 
+ * ```
+ *
+ * Elements by their ID are made available by browsers on the `window` object,
+ * which is a security risk.
+ * Using a prefix solves this problem.
+ *
+ * More information on how to handle clobbering and the prefix is explained in
+ * *Example: headings (DOM clobbering)* in `rehype-sanitize`.
+ *
+ * ###### Unknown nodes
+ *
+ * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.
+ * The default behavior for unknown nodes is:
+ *
+ * * when the node has a `value`
+ *   (and doesn’t have `data.hName`, `data.hProperties`, or `data.hChildren`,
+ *   see later),
+ *   create a hast `text` node
+ * * otherwise,
+ *   create a `
` element (which could be changed with `data.hName`),
+ *   with its children mapped from mdast to hast as well
+ *
+ * This behavior can be changed by passing an `unknownHandler`.
+ *
+ * @overload
+ * @param {Processor} processor
+ * @param {Readonly | null | undefined} [options]
+ * @returns {TransformBridge}
+ *
+ * @overload
+ * @param {Readonly | null | undefined} [options]
+ * @returns {TransformMutate}
+ *
+ * @overload
+ * @param {Readonly | Processor | null | undefined} [destination]
+ * @param {Readonly | null | undefined} [options]
+ * @returns {TransformBridge | TransformMutate}
+ *
+ * @param {Readonly | Processor | null | undefined} [destination]
+ *   Processor or configuration (optional).
+ * @param {Readonly | null | undefined} [options]
+ *   When a processor was given,
+ *   configuration (optional).
+ * @returns {TransformBridge | TransformMutate}
+ *   Transform.
+ */
+export default function remarkRehype(destination?: Readonly | Processor | null | undefined, options?: Readonly | null | undefined): TransformBridge | TransformMutate;
+export type Options = Omit;
+/**
+ * Bridge-mode.
+ *
+ * Runs the destination with the new hast tree.
+ * Discards result.
+ */
+export type TransformBridge = (tree: MdastRoot, file: VFile) => Promise;
+/**
+ * Mutate-mode.
+ *
+ * Further transformers run on the hast tree.
+ */
+export type TransformMutate = (tree: MdastRoot, file: VFile) => HastRoot;
+import type { Processor } from 'unified';
+import type { Options as ToHastOptions } from 'mdast-util-to-hast';
+import type { Root as MdastRoot } from 'mdast';
+import type { VFile } from 'vfile';
+import type { Root as HastRoot } from 'hast';
+//# sourceMappingURL=index.d.ts.map
\ No newline at end of file
diff --git a/tools/ui/node_modules/remark-rehype/lib/index.d.ts.map b/tools/ui/node_modules/remark-rehype/lib/index.d.ts.map
new file mode 100644
index 0000000000000000000000000000000000000000..4ccd01574e32539d9784d739f433258ce8cab581
--- /dev/null
+++ b/tools/ui/node_modules/remark-rehype/lib/index.d.ts.map
@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6HG,gDACQ,SAAS,YACT,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GAClC,eAAe,CAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+CACQ,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GAClC,eAAe,CAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,mDACQ,QAAQ,CAAC,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI,GAAG,SAAS,YAChD,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GAClC,eAAe,GAAG,eAAe,CAE3C;sBAlIU,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC;;;;;;;qCAO7B,SAAS,QAET,KAAK,KAEH,OAAO,CAAC,SAAS,CAAC;;;;;;qCAOpB,SAAS,QAET,KAAK,KAEH,QAAQ;+BA3BO,SAAS;8CADM,oBAAoB;uCAD3B,OAAO;2BAGnB,OAAO;sCAJI,MAAM"}
\ No newline at end of file
diff --git a/tools/ui/node_modules/remark-rehype/lib/index.js b/tools/ui/node_modules/remark-rehype/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..26e264fb8af57c9adb96299f2ca67cfc94d62bed
--- /dev/null
+++ b/tools/ui/node_modules/remark-rehype/lib/index.js
@@ -0,0 +1,175 @@
+/**
+ * @import {Root as HastRoot} from 'hast'
+ * @import {Root as MdastRoot} from 'mdast'
+ * @import {Options as ToHastOptions} from 'mdast-util-to-hast'
+ * @import {Processor} from 'unified'
+ * @import {VFile} from 'vfile'
+ */
+
+/**
+ * @typedef {Omit} Options
+ *
+ * @callback TransformBridge
+ *   Bridge-mode.
+ *
+ *   Runs the destination with the new hast tree.
+ *   Discards result.
+ * @param {MdastRoot} tree
+ *   Tree.
+ * @param {VFile} file
+ *   File.
+ * @returns {Promise}
+ *   Nothing.
+ *
+ * @callback TransformMutate
+ *  Mutate-mode.
+ *
+ *  Further transformers run on the hast tree.
+ * @param {MdastRoot} tree
+ *   Tree.
+ * @param {VFile} file
+ *   File.
+ * @returns {HastRoot}
+ *   Tree (hast).
+ */
+
+import {toHast} from 'mdast-util-to-hast'
+
+/**
+ * Turn markdown into HTML.
+ *
+ * ##### Notes
+ *
+ * ###### Signature
+ *
+ * * if a processor is given,
+ *   runs the (rehype) plugins used on it with a hast tree,
+ *   then discards the result (*bridge mode*)
+ * * otherwise,
+ *   returns a hast tree,
+ *   the plugins used after `remarkRehype` are rehype plugins (*mutate mode*)
+ *
+ * > 👉 **Note**:
+ * > It’s highly unlikely that you want to pass a `processor`.
+ *
+ * ###### HTML
+ *
+ * Raw HTML is available in mdast as `html` nodes and can be embedded in hast
+ * as semistandard `raw` nodes.
+ * Most plugins ignore `raw` nodes but two notable ones don’t:
+ *
+ * * `rehype-stringify` also has an option `allowDangerousHtml` which will
+ *   output the raw HTML.
+ *   This is typically discouraged as noted by the option name but is useful if
+ *   you completely trust authors
+ * * `rehype-raw` can handle the raw embedded HTML strings by parsing them
+ *   into standard hast nodes (`element`, `text`, etc);
+ *   this is a heavy task as it needs a full HTML parser,
+ *   but it is the only way to support untrusted content
+ *
+ * ###### Footnotes
+ *
+ * Many options supported here relate to footnotes.
+ * Footnotes are not specified by CommonMark,
+ * which we follow by default.
+ * They are supported by GitHub,
+ * so footnotes can be enabled in markdown with `remark-gfm`.
+ *
+ * The options `footnoteBackLabel` and `footnoteLabel` define natural language
+ * that explains footnotes,
+ * which is hidden for sighted users but shown to assistive technology.
+ * When your page is not in English,
+ * you must define translated values.
+ *
+ * Back references use ARIA attributes,
+ * but the section label itself uses a heading that is hidden with an
+ * `sr-only` class.
+ * To show it to sighted users,
+ * define different attributes in `footnoteLabelProperties`.
+ *
+ * ###### Clobbering
+ *
+ * Footnotes introduces a problem,
+ * as it links footnote calls to footnote definitions on the page through `id`
+ * attributes generated from user content,
+ * which results in DOM clobbering.
+ *
+ * DOM clobbering is this:
+ *
+ * ```html
+ * 

+ * 
+ * ```
+ *
+ * Elements by their ID are made available by browsers on the `window` object,
+ * which is a security risk.
+ * Using a prefix solves this problem.
+ *
+ * More information on how to handle clobbering and the prefix is explained in
+ * *Example: headings (DOM clobbering)* in `rehype-sanitize`.
+ *
+ * ###### Unknown nodes
+ *
+ * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.
+ * The default behavior for unknown nodes is:
+ *
+ * * when the node has a `value`
+ *   (and doesn’t have `data.hName`, `data.hProperties`, or `data.hChildren`,
+ *   see later),
+ *   create a hast `text` node
+ * * otherwise,
+ *   create a `
` element (which could be changed with `data.hName`),
+ *   with its children mapped from mdast to hast as well
+ *
+ * This behavior can be changed by passing an `unknownHandler`.
+ *
+ * @overload
+ * @param {Processor} processor
+ * @param {Readonly | null | undefined} [options]
+ * @returns {TransformBridge}
+ *
+ * @overload
+ * @param {Readonly | null | undefined} [options]
+ * @returns {TransformMutate}
+ *
+ * @overload
+ * @param {Readonly | Processor | null | undefined} [destination]
+ * @param {Readonly | null | undefined} [options]
+ * @returns {TransformBridge | TransformMutate}
+ *
+ * @param {Readonly | Processor | null | undefined} [destination]
+ *   Processor or configuration (optional).
+ * @param {Readonly | null | undefined} [options]
+ *   When a processor was given,
+ *   configuration (optional).
+ * @returns {TransformBridge | TransformMutate}
+ *   Transform.
+ */
+export default function remarkRehype(destination, options) {
+  if (destination && 'run' in destination) {
+    /**
+     * @type {TransformBridge}
+     */
+    return async function (tree, file) {
+      // Cast because root in -> root out.
+      const hastTree = /** @type {HastRoot} */ (
+        toHast(tree, {file, ...options})
+      )
+      await destination.run(hastTree, file)
+    }
+  }
+
+  /**
+   * @type {TransformMutate}
+   */
+  return function (tree, file) {
+    // Cast because root in -> root out.
+    // To do: in the future, disallow ` || options` fallback.
+    // With `unified-engine`, `destination` can be `undefined` but
+    // `options` will be the file set.
+    // We should not pass that as `options`.
+    return /** @type {HastRoot} */ (
+      toHast(tree, {file, ...(destination || options)})
+    )
+  }
+}
diff --git a/tools/ui/node_modules/remark-rehype/license b/tools/ui/node_modules/remark-rehype/license
new file mode 100644
index 0000000000000000000000000000000000000000..bc8f165a62768a19de38901d81ac662c51ff29db
--- /dev/null
+++ b/tools/ui/node_modules/remark-rehype/license
@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) Titus Wormer 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/tools/ui/node_modules/remark-rehype/package.json b/tools/ui/node_modules/remark-rehype/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..605c2ef255db1faa966d0fc031356f74770e657c
--- /dev/null
+++ b/tools/ui/node_modules/remark-rehype/package.json
@@ -0,0 +1,86 @@
+{
+  "author": "Titus Wormer  (https://wooorm.com)",
+  "bugs": "https://github.com/remarkjs/remark-rehype/issues",
+  "contributors": [
+    "John Otander  (https://johno.com)",
+    "Titus Wormer  (https://wooorm.com)"
+  ],
+  "dependencies": {
+    "@types/hast": "^3.0.0",
+    "@types/mdast": "^4.0.0",
+    "mdast-util-to-hast": "^13.0.0",
+    "unified": "^11.0.0",
+    "vfile": "^6.0.0"
+  },
+  "description": "remark plugin that turns markdown into HTML to support rehype",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "c8": "^10.0.0",
+    "prettier": "^3.0.0",
+    "rehype-slug": "^6.0.0",
+    "rehype-stringify": "^10.0.0",
+    "remark-cli": "^12.0.0",
+    "remark-parse": "^11.0.0",
+    "remark-preset-wooorm": "^11.0.0",
+    "remark-stringify": "^11.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^5.0.0",
+    "xo": "^0.60.0"
+  },
+  "exports": "./index.js",
+  "files": [
+    "index.d.ts.map",
+    "index.d.ts",
+    "index.js",
+    "lib/"
+  ],
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "keywords": [
+    "hast",
+    "html",
+    "markdown",
+    "mdast",
+    "plugin",
+    "rehype-plugin",
+    "rehype",
+    "remark-plugin",
+    "remark",
+    "unified"
+  ],
+  "license": "MIT",
+  "name": "remark-rehype",
+  "prettier": {
+    "bracketSpacing": false,
+    "singleQuote": true,
+    "semi": false,
+    "tabWidth": 2,
+    "trailingComma": "none",
+    "useTabs": false
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-wooorm"
+    ]
+  },
+  "repository": "remarkjs/remark-rehype",
+  "scripts": {
+    "build": "tsc --build --clean && tsc --build && type-coverage",
+    "format": "remark --frail --output --quiet -- . && prettier --log-level warn --write -- . && xo --fix",
+    "test-api": "node --conditions development test.js",
+    "test-coverage": "c8 --100 --reporter lcov -- npm run test-api",
+    "test": "npm run build && npm run format && npm run test-coverage"
+  },
+  "sideEffects": false,
+  "typeCoverage": {
+    "atLeast": 100,
+    "strict": true
+  },
+  "type": "module",
+  "version": "11.1.2",
+  "xo": {
+    "prettier": true
+  }
+}
diff --git a/tools/ui/node_modules/remark-rehype/readme.md b/tools/ui/node_modules/remark-rehype/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..ad20328778ddb28fbcb364bb3e417b89ce744441
--- /dev/null
+++ b/tools/ui/node_modules/remark-rehype/readme.md
@@ -0,0 +1,802 @@
+# remark-rehype
+
+[![Build][badge-build-image]][badge-build-url]
+[![Coverage][badge-coverage-image]][badge-coverage-url]
+[![Downloads][badge-downloads-image]][badge-downloads-url]
+[![Size][badge-size-image]][badge-size-url]
+
+**[remark][github-remark]** plugin that turns markdown into HTML to support
+**[rehype][github-rehype]**.
+
+## Contents
+
+* [What is this?](#what-is-this)
+* [When should I use this?](#when-should-i-use-this)
+* [Install](#install)
+* [Use](#use)
+* [API](#api)
+  * [`defaultFootnoteBackContent(referenceIndex, rereferenceIndex)`](#defaultfootnotebackcontentreferenceindex-rereferenceindex)
+  * [`defaultFootnoteBackLabel(referenceIndex, rereferenceIndex)`](#defaultfootnotebacklabelreferenceindex-rereferenceindex)
+  * [`defaultHandlers`](#defaulthandlers)
+  * [`unified().use(remarkRehype[, destination][, options])`](#unifieduseremarkrehype-destination-options)
+  * [`Options`](#options)
+* [Examples](#examples)
+  * [Example: supporting HTML in markdown naïvely](#example-supporting-html-in-markdown-naïvely)
+  * [Example: supporting HTML in markdown properly](#example-supporting-html-in-markdown-properly)
+  * [Example: footnotes in languages other than English](#example-footnotes-in-languages-other-than-english)
+* [HTML](#html-1)
+* [CSS](#css)
+* [Syntax tree](#syntax-tree)
+* [Types](#types)
+* [Compatibility](#compatibility)
+* [Security](#security)
+* [Related](#related)
+* [Contribute](#contribute)
+* [License](#license)
+
+## What is this?
+
+This package is a [unified][github-unified] ([remark][github-remark])
+plugin that switches from remark (the markdown ecosystem)
+to rehype (the HTML ecosystem).
+It does this by transforming the current markdown (mdast) syntax tree into an
+HTML (hast) syntax tree.
+remark plugins deal with mdast and rehype plugins deal with hast,
+so plugins used after `remark-rehype` have to be rehype plugins.
+
+The reason that there are different ecosystems for markdown and HTML is that
+turning markdown into HTML is,
+while frequently needed,
+not the only purpose of markdown.
+Checking (linting) and formatting markdown are also common use cases for
+remark and markdown.
+There are several aspects of markdown that do not translate 1-to-1 to HTML.
+In some cases markdown contains more information than HTML:
+for example,
+there are several ways to add a link in markdown
+(as in,
+autolinks: ``,
+resource links: `[label](url)`,
+and reference links with definitions:
+`[label][id]` and `[id]: url`).
+In other cases HTML contains more information than markdown:
+there are many tags,
+which add new meaning (semantics),
+available in HTML that aren’t available in markdown.
+If there was just one AST,
+it would be quite hard to perform the tasks that several remark and rehype
+plugins currently do.
+
+## When should I use this?
+
+This project is useful when you want to turn markdown to HTML.
+It opens up a whole new ecosystem with tons of plugins to do all kinds of
+things.
+You can [minify HTML][github-rehype-minify],
+[format HTML][github-rehype-format],
+[make sure it’s safe][github-rehype-sanitize],
+[highlight code][github-rehype-starry-night],
+[add metadata][github-rehype-meta],
+and a lot more.
+
+A different plugin,
+[`rehype-raw`][github-rehype-raw],
+adds support for raw HTML written inside markdown.
+This is a separate plugin because supporting HTML inside markdown is a heavy
+task (performance and bundle size) and not always needed.
+To use both together,
+you also have to configure `remark-rehype` with `allowDangerousHtml: true` and
+then use `rehype-raw`.
+
+The rehype plugin [`rehype-remark`][github-rehype-remark] does the inverse of
+this plugin.
+It turns HTML into markdown.
+
+If you don’t use plugins and want to access syntax trees,
+you can use
+[`mdast-util-to-hast`][github-mdast-util-to-hast].
+
+## Install
+
+This package is [ESM only][github-gist-esm].
+In Node.js (version 16+),
+install with [npm][npmjs-install]:
+
+```sh
+npm install remark-rehype
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import remarkRehype from 'https://esm.sh/remark-rehype@11'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+
+```
+
+## Use
+
+Say our document `example.md` contains:
+
+```markdown
+# Pluto
+
+**Pluto** (minor-planet designation: **134340 Pluto**) is a
+[dwarf planet](https://en.wikipedia.org/wiki/Dwarf_planet) in the
+[Kuiper belt](https://en.wikipedia.org/wiki/Kuiper_belt).
+```
+
+…and our module `example.js` contains:
+
+```js
+import rehypeDocument from 'rehype-document'
+import rehypeFormat from 'rehype-format'
+import rehypeStringify from 'rehype-stringify'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import {read} from 'to-vfile'
+import {unified} from 'unified'
+import {reporter} from 'vfile-reporter'
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkRehype)
+  .use(rehypeDocument)
+  .use(rehypeFormat)
+  .use(rehypeStringify)
+  .process(await read('example.md'))
+
+console.error(reporter(file))
+console.log(String(file))
+```
+
+…then running `node example.js` yields:
+
+```text
+example.md: no issues found
+```
+
+```html
+
+
+  
+    
+    example
+    
+  
+  
+    
Pluto

+    

+      Pluto (minor-planet designation: 134340 Pluto) is a
+      dwarf planet in the
+      Kuiper belt.
+    

+  
+
+```
+
+## API
+
+This package exports the identifiers
+[`defaultFootnoteBackContent`][api-default-footnote-back-content],
+[`defaultFootnoteBackLabel`][api-default-footnote-back-label],
+and
+[`defaultHandlers`][api-default-handlers].
+The default export is [`remarkRehype`][api-remark-rehype].
+
+### `defaultFootnoteBackContent(referenceIndex, rereferenceIndex)`
+
+See [`defaultFootnoteBackContent` from
+`mdast-util-to-hast`][github-mdast-util-to-hast-default-back-content].
+
+### `defaultFootnoteBackLabel(referenceIndex, rereferenceIndex)`
+
+See [`defaultFootnoteBackLabel` from
+`mdast-util-to-hast`][github-mdast-util-to-hast-default-back-label].
+
+### `defaultHandlers`
+
+See [`defaultHandlers` from
+`mdast-util-to-hast`][github-mdast-util-to-hast-default-handlers].
+
+### `unified().use(remarkRehype[, destination][, options])`
+
+Turn markdown into HTML.
+
+###### Parameters
+
+* `destination`
+  ([`Processor`][github-unified-processor], optional)
+  — processor
+* `options`
+  ([`Options`][api-options], optional)
+  — configuration
+
+###### Returns
+
+Transform ([`Transformer`][github-unified-transformer]).
+
+##### Notes
+
+###### Signature
+
+* if a [processor][github-unified-processor] is given,
+  runs the (rehype) plugins used on it with a hast tree,
+  then discards the result
+  ([*bridge mode*][github-unified-mode])
+* otherwise,
+  returns a hast tree,
+  the plugins used after `remarkRehype` are rehype plugins
+  ([*mutate mode*][github-unified-mode])
+
+> 👉 **Note**:
+> it’s highly unlikely that you want to pass a `processor`.
+
+###### HTML
+
+Raw HTML is available in mdast as [`html`][github-mdast-html] nodes and can be
+embedded in hast as semistandard `raw` nodes.
+Most plugins ignore `raw` nodes but two notable ones don’t:
+
+* [`rehype-stringify`][github-rehype-stringify] also has an option
+  `allowDangerousHtml` which will output the raw HTML;
+  this is typically discouraged as noted by the option name but is useful if
+  you completely trust authors
+* [`rehype-raw`][github-rehype-raw] can handle the raw embedded HTML strings by
+  parsing them into standard hast nodes
+  (`element`, `text`, etc);
+  This is a heavy task as it needs a full HTML parser,
+  but it is the only way to support untrusted content
+
+###### Footnotes
+
+Many options supported here relate to footnotes.
+Footnotes are not specified by CommonMark,
+which we follow by default.
+They are supported by GitHub,
+so footnotes can be enabled in markdown with [`remark-gfm`][github-remark-gfm].
+
+The options `footnoteBackLabel` and `footnoteLabel` define natural language
+that explains footnotes,
+which is hidden for sighted users but shown to assistive technology.
+When your page is not in English,
+you must define translated values.
+
+Back references use ARIA attributes,
+but the section label itself uses a heading that is hidden with an
+`sr-only` class.
+To show it to sighted users,
+define different attributes in `footnoteLabelProperties`.
+
+###### Clobbering
+
+Footnotes introduces a problem,
+as it links footnote calls to footnote definitions on the page through `id`
+attributes generated from user content,
+which results in DOM clobbering.
+
+DOM clobbering is this:
+
+```html
+

+
+```
+
+Elements by their ID are made available by browsers on the `window` object,
+which is a security risk.
+Using a prefix solves this problem.
+
+More information on how to handle clobbering and the prefix is explained in
+[*Example: headings (DOM clobbering)* in
+`rehype-sanitize`][github-rehype-sanitize-clobber].
+
+###### Unknown nodes
+
+Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.
+The default behavior for unknown nodes is:
+
+* when the node has a `value`
+  (and doesn’t have `data.hName`, `data.hProperties`, or `data.hChildren`,
+  see later),
+  create a hast `text` node
+* otherwise,
+  create a `
` element
+  (which could be changed with `data.hName`),
+  with its children mapped from mdast to hast as well
+
+This behavior can be changed by passing an `unknownHandler`.
+
+### `Options`
+
+Configuration (TypeScript type).
+
+###### Fields
+
+* `allowDangerousHtml`
+  (`boolean`, default: `false`)
+  — whether to persist raw HTML in markdown in the hast tree
+* `clobberPrefix`
+  (`string`, default: `'user-content-'`)
+  — prefix to use before the `id` property on footnotes to prevent them from
+  *clobbering*
+* `footnoteBackContent`
+  ([`FootnoteBackContentTemplate` from
+  `mdast-util-to-hast`][github-mdast-util-to-hast-back-content-template]
+  or `string`, default:
+  [`defaultFootnoteBackContent` from
+  `mdast-util-to-hast`][github-mdast-util-to-hast-default-back-content])
+  — content of the backreference back to references
+* `footnoteBackLabel`
+  ([`FootnoteBackLabelTemplate` from
+  `mdast-util-to-hast`][github-mdast-util-to-hast-back-label-template]
+  or `string`, default:
+  [`defaultFootnoteBackLabel` from
+  `mdast-util-to-hast`][github-mdast-util-to-hast-default-back-label])
+  — label to describe the backreference back to references
+* `footnoteLabel`
+  (`string`, default: `'Footnotes'`)
+  — label to use for the footnotes section (affects screen readers)
+* `footnoteLabelProperties`
+  ([`Properties` from `@types/hast`][github-hast-properties], default:
+  `{className: ['sr-only']}`)
+  — properties to use on the footnote label
+  (note that `id: 'footnote-label'` is always added as footnote calls use it
+  with `aria-describedby` to provide an accessible label)
+* `footnoteLabelTagName`
+  (`string`, default: `h2`)
+  — tag name to use for the footnote label
+* `handlers`
+  ([`Handlers` from
+  `mdast-util-to-hast`][github-mdast-util-to-hast-handlers], optional)
+  — extra handlers for nodes
+* `passThrough`
+  (`Array`, optional)
+  — list of custom mdast node types to pass through (keep) in hast (note that
+  the node itself is passed, but eventual children are transformed)
+* `unknownHandler`
+  ([`Handler` from
+  `mdast-util-to-hast`][github-mdast-util-to-hast-handler], optional)
+  — handle all unknown nodes
+
+## Examples
+
+### Example: supporting HTML in markdown naïvely
+
+If you completely trust the authors of the input markdown and want to allow them
+to write HTML inside markdown,
+you can pass `allowDangerousHtml` to `remark-rehype` and `rehype-stringify`:
+
+```js
+import rehypeStringify from 'rehype-stringify'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import {unified} from 'unified'
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkRehype, {allowDangerousHtml: true})
+  .use(rehypeStringify, {allowDangerousHtml: true})
+  .process('Dysnomia')
+
+console.log(String(file))
+```
+
+Yields:
+
+```html
+
Dysnomia

+```
+
+> ⚠️ **Danger**:
+> observe that the XSS attack through `onclick` is present.
+
+### Example: supporting HTML in markdown properly
+
+If you do not trust the authors of the input markdown,
+or if you want to make sure that rehype plugins can see HTML embedded in
+markdown,
+use [`rehype-raw`][github-rehype-raw].
+The following example passes `allowDangerousHtml` to `remark-rehype`,
+then turns the raw embedded HTML into proper HTML nodes with `rehype-raw`,
+and finally sanitizes the HTML by only allowing safe things with
+`rehype-sanitize`:
+
+```js
+import rehypeSanitize from 'rehype-sanitize'
+import rehypeStringify from 'rehype-stringify'
+import rehypeRaw from 'rehype-raw'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import {unified} from 'unified'
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkRehype, {allowDangerousHtml: true})
+  .use(rehypeRaw)
+  .use(rehypeSanitize)
+  .use(rehypeStringify)
+  .process('Dysnomia')
+
+console.log(String(file))
+```
+
+Running that code yields:
+
+```html
+
Dysnomia

+```
+
+> ⚠️ **Danger**:
+> observe that the XSS attack through `onclick` is **not** present.
+
+### Example: footnotes in languages other than English
+
+If you know that the markdown is authored in a language other than English,
+and you’re using `remark-gfm` to match how GitHub renders markdown,
+and you know that footnotes are (or can?) be used,
+you should translate the labels associated with them.
+
+Let’s first set the stage:
+
+```js
+import {unified} from 'unified'
+import remarkParse from 'remark-parse'
+import remarkGfm from 'remark-gfm'
+import remarkRehype from 'remark-rehype'
+import rehypeStringify from 'rehype-stringify'
+
+const doc = `
+Ceres ist nach der römischen Göttin des Ackerbaus benannt;
+ihr astronomisches Symbol ist daher eine stilisierte Sichel: ⚳.[^nasa-2015]
+
+[^nasa-2015]: JPL/NASA:
+    [*What is a Dwarf Planet?*](https://www.jpl.nasa.gov/infographics/what-is-a-dwarf-planet)
+    In: Jet Propulsion Laboratory.
+    22. April 2015,
+    abgerufen am 19. Januar 2022 (englisch).
+`
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkGfm)
+  .use(remarkRehype)
+  .use(rehypeStringify)
+  .process(doc)
+
+console.log(String(file))
+```
+
+Yields:
+
+```html
+
Ceres ist nach der römischen Göttin des Ackerbaus benannt;
+ihr astronomisches Symbol ist daher eine stilisierte Sichel: ⚳.1

+
Footnotes

+
    
+
  1. 
+
    JPL/NASA:
+What is a Dwarf Planet?
+In: Jet Propulsion Laboratory.
+22. April 2015,
+abgerufen am 19. Januar 2022 (englisch). ↩
    
+
    2. 
+

+

+```
+
+This is a mix of English and German that isn’t very accessible,
+such as that screen readers can’t handle it nicely.
+Let’s say our program *does* know that the markdown is in German.
+In that case,
+it’s important to translate and define the labels relating to footnotes so that
+screen reader users can properly pronounce the page:
+
+```diff
+@@ -18,7 +18,16 @@ ihr astronomisches Symbol ist daher eine stilisierte Sichel: ⚳.[^nasa-2015]
+ const file = await unified()
+   .use(remarkParse)
+   .use(remarkGfm)
+-  .use(remarkRehype)
++  .use(remarkRehype, {
++    footnoteBackLabel(referenceIndex, rereferenceIndex) {
++      return (
++        'Hochspringen nach: ' +
++        (referenceIndex + 1) +
++        (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')
++      )
++    },
++    footnoteLabel: 'Fußnoten'
++  })
+   .use(rehypeStringify)
+   .process(doc)
+```
+
+Running the code with the above patch applied,
+yields:
+
+```diff
+@@ -1,13 +1,13 @@
+ 
Ceres ist nach der römischen Göttin des Ackerbaus benannt;
+ ihr astronomisches Symbol ist daher eine stilisierte Sichel: ⚳.1

+-
Footnotes

++
Fußnoten

+ 
    
+ 
  1. 
+ 
    JPL/NASA:
+ What is a Dwarf Planet?
+ In: Jet Propulsion Laboratory.
+ 22. April 2015,
+-abgerufen am 19. Januar 2022 (englisch). ↩
    
++abgerufen am 19. Januar 2022 (englisch). ↩
    
+ 
    2. 
+ 

+ 

+```
+
+## HTML
+
+See [*Algorithm* in
+`mdast-util-to-hast`](https://github.com/syntax-tree/mdast-util-to-hast#algorithm)
+for info on how mdast (markdown) nodes are transformed to hast (HTML).
+
+## CSS
+
+Assuming you know how to use (semantic) HTML and CSS,
+then it should generally be straightforward to style the HTML produced by this
+plugin.
+With CSS,
+you can get creative and style the results as you please.
+
+Some semistandard features,
+notably GFMs tasklists and footnotes,
+generate HTML that be unintuitive,
+as it matches exactly what GitHub produces for their website.
+There is a project,
+[`sindresorhus/github-markdown-css`][github-markdown-css],
+that exposes the stylesheet that GitHub uses for rendered markdown,
+which might either be inspirational for more complex features,
+or can be used as-is to exactly match how GitHub styles rendered markdown.
+
+The following CSS is needed to make footnotes look a bit like GitHub:
+
+```css
+/* Style the footnotes section. */
+.footnotes {
+  font-size: smaller;
+  color: #8b949e;
+  border-top: 1px solid #30363d;
+}
+
+/* Hide the section label for visual users. */
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  word-wrap: normal;
+  border: 0;
+}
+
+/* Place `[` and `]` around footnote calls. */
+[data-footnote-ref]::before {
+  content: '[';
+}
+
+[data-footnote-ref]::after {
+  content: ']';
+}
+```
+
+## Syntax tree
+
+This projects turns [mdast][github-mdast] (markdown) into [hast][github-hast]
+(HTML).
+
+It extends mdast by supporting `data` fields on mdast nodes to specify how they
+should be transformed.
+See [*Fields on nodes* in
+`mdast-util-to-hast`](https://github.com/syntax-tree/mdast-util-to-hast#fields-on-nodes)
+for info on how these fields work.
+
+It extends hast by using a semistandard raw nodes for raw HTML.
+See the [*HTML* note above](#html) for more info.
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the types
+[`Options`][api-options].
+
+The types of `mdast-util-to-hast` can be referenced to register data fields
+with `@types/mdast` and `Raw` nodes with `@types/hast`.
+
+```js
+/**
+ * @import {Root as HastRoot} from 'hast'
+ * @import {Root as MdastRoot} from 'mdast'
+ * @import {} from 'mdast-util-to-hast'
+ */
+
+import {visit} from 'unist-util-visit'
+
+const mdastNode = /** @type {MdastRoot} */ ({/* … */})
+console.log(mdastNode.data?.hName) // Typed as `string | undefined`.
+
+const hastNode = /** @type {HastRoot} */ ({/* … */})
+
+visit(hastNode, function (node) {
+  // `node` can now be `raw`.
+})
+```
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release,
+we drop support for unmaintained versions of Node.
+This means we try to keep the current release line,
+`remark-rehype@11`,
+compatible with Node.js 16.
+
+This plugin works with `unified` version 6+,
+`remark-parse` version 3+
+(used in `remark` version 7),
+and `rehype-stringify` version 3+
+(used in `rehype` version 5).
+
+## Security
+
+Use of `remark-rehype` can open you up to a
+[cross-site scripting (XSS)][wikipedia-xss] attack.
+Embedded **[hast][github-hast]** properties
+(`hName`, `hProperties`, `hChildren`)
+in [mdast][github-mdast],
+custom handlers,
+and the `allowDangerousHtml` option all provide openings.
+Use [`rehype-sanitize`][github-rehype-sanitize] to make the tree safe.
+
+## Related
+
+* [`rehype-raw`][github-rehype-raw]
+  — rehype plugin to parse the tree again and support `raw` nodes
+* [`rehype-sanitize`][github-rehype-sanitize]
+  — rehype plugin to sanitize HTML
+* [`rehype-remark`][github-rehype-remark]
+  — rehype plugin to turn HTML into markdown
+* [`rehype-retext`](https://github.com/rehypejs/rehype-retext)
+  — rehype plugin to support retext
+* [`remark-retext`](https://github.com/remarkjs/remark-retext)
+  — remark plugin to support retext
+
+## Contribute
+
+See [`contributing.md`][health-contributing] in [`remarkjs/.github`][health]
+for ways to get started.
+See [`support.md`][health-support] for ways to get help.
+
+This project has a [code of conduct][health-coc].
+By interacting with this repository,
+organization,
+or community you agree to abide by its terms.
+
+## License
+
+[MIT][file-license] © [Titus Wormer][wooorm]
+
+
+
+[api-default-footnote-back-content]: #defaultfootnotebackcontentreferenceindex-rereferenceindex
+
+[api-default-footnote-back-label]: #defaultfootnotebacklabelreferenceindex-rereferenceindex
+
+[api-default-handlers]: #defaulthandlers
+
+[api-options]: #options
+
+[api-remark-rehype]: #unifieduseremarkrehype-destination-options
+
+[badge-build-image]: https://github.com/remarkjs/remark-rehype/workflows/main/badge.svg
+
+[badge-build-url]: https://github.com/remarkjs/remark-rehype/actions
+
+[badge-coverage-image]: https://img.shields.io/codecov/c/github/remarkjs/remark-rehype.svg
+
+[badge-coverage-url]: https://codecov.io/github/remarkjs/remark-rehype
+
+[badge-downloads-image]: https://img.shields.io/npm/dm/remark-rehype.svg
+
+[badge-downloads-url]: https://www.npmjs.com/package/remark-rehype
+
+[badge-size-image]: https://img.shields.io/bundlejs/size/remark-rehype
+
+[badge-size-url]: https://bundlejs.com/?q=remark-rehype
+
+[esmsh]: https://esm.sh
+
+[file-license]: license
+
+[github-gist-esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[github-hast]: https://github.com/syntax-tree/hast
+
+[github-hast-properties]: https://github.com/syntax-tree/hast#properties
+
+[github-markdown-css]: https://github.com/sindresorhus/github-markdown-css
+
+[github-mdast]: https://github.com/syntax-tree/mdast
+
+[github-mdast-html]: https://github.com/syntax-tree/mdast#html
+
+[github-mdast-util-to-hast]: https://github.com/syntax-tree/mdast-util-to-hast
+
+[github-mdast-util-to-hast-back-content-template]: https://github.com/syntax-tree/mdast-util-to-hast#footnotebackcontenttemplate
+
+[github-mdast-util-to-hast-back-label-template]: https://github.com/syntax-tree/mdast-util-to-hast#footnotebacklabeltemplate
+
+[github-mdast-util-to-hast-default-back-content]: https://github.com/syntax-tree/mdast-util-to-hast#defaultfootnotebackcontentreferenceindex-rereferenceindex
+
+[github-mdast-util-to-hast-default-back-label]: https://github.com/syntax-tree/mdast-util-to-hast#defaultfootnotebacklabelreferenceindex-rereferenceindex
+
+[github-mdast-util-to-hast-default-handlers]: https://github.com/syntax-tree/mdast-util-to-hast#defaulthandlers
+
+[github-mdast-util-to-hast-handler]: https://github.com/syntax-tree/mdast-util-to-hast#handler
+
+[github-mdast-util-to-hast-handlers]: https://github.com/syntax-tree/mdast-util-to-hast#handlers
+
+[github-rehype]: https://github.com/rehypejs/rehype
+
+[github-rehype-format]: https://github.com/rehypejs/rehype-format
+
+[github-rehype-meta]: https://github.com/rehypejs/rehype-meta
+
+[github-rehype-minify]: https://github.com/rehypejs/rehype-minify
+
+[github-rehype-raw]: https://github.com/rehypejs/rehype-raw
+
+[github-rehype-remark]: https://github.com/rehypejs/rehype-remark
+
+[github-rehype-sanitize]: https://github.com/rehypejs/rehype-sanitize
+
+[github-rehype-sanitize-clobber]: https://github.com/rehypejs/rehype-sanitize#example-headings-dom-clobbering
+
+[github-rehype-starry-night]: https://github.com/rehypejs/rehype-starry-night
+
+[github-rehype-stringify]: https://github.com/rehypejs/rehype/tree/main/packages/rehype-stringify
+
+[github-remark]: https://github.com/remarkjs/remark
+
+[github-remark-gfm]: https://github.com/remarkjs/remark-gfm
+
+[github-unified]: https://github.com/unifiedjs/unified
+
+[github-unified-mode]: https://github.com/unifiedjs/unified#transforming-between-ecosystems
+
+[github-unified-processor]: https://github.com/unifiedjs/unified#processor
+
+[github-unified-transformer]: https://github.com/unifiedjs/unified#transformer
+
+[health]: https://github.com/remarkjs/.github
+
+[health-coc]: https://github.com/remarkjs/.github/blob/main/code-of-conduct.md
+
+[health-contributing]: https://github.com/remarkjs/.github/blob/main/contributing.md
+
+[health-support]: https://github.com/remarkjs/.github/blob/main/support.md
+
+[npmjs-install]: https://docs.npmjs.com/cli/install
+
+[typescript]: https://www.typescriptlang.org
+
+[wikipedia-xss]: https://en.wikipedia.org/wiki/Cross-site_scripting
+
+[wooorm]: https://wooorm.com
diff --git a/tools/ui/node_modules/remark-stringify/index.d.ts b/tools/ui/node_modules/remark-stringify/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0b266fce60efda41e7ad2aa74eb656d0d7052403
--- /dev/null
+++ b/tools/ui/node_modules/remark-stringify/index.d.ts
@@ -0,0 +1,41 @@
+import type {Root} from 'mdast'
+import type {Options as ToMarkdownExtension} from 'mdast-util-to-markdown'
+import type {Plugin} from 'unified'
+import type {Options} from './lib/index.js'
+
+export type {Options} from './lib/index.js'
+
+/**
+ * Add support for serializing to markdown.
+ *
+ * @this
+ *   Unified processor.
+ * @param
+ *   Configuration (optional).
+ * @returns
+ *   Nothing.
+ */
+declare const remarkStringify: Plugin<
+  [(Readonly | null | undefined)?],
+  Root,
+  string
+>
+export default remarkStringify
+
+// Add custom settings supported when `remark-stringify` is added.
+declare module 'unified' {
+  interface Settings extends Options {}
+
+  interface Data {
+    /**
+     * List of `mdast-util-to-markdown` extensions to use.
+     *
+     * This type is registered by `remark-stringify`.
+     * Values can be registered by remark plugins that extend
+     * `mdast-util-to-markdown`.
+     * See {@link ToMarkdownExtension | `Options`} from
+     * {@link https://github.com/syntax-tree/mdast-util-to-markdown#options | `mdast-util-to-markdown`}.
+     */
+    toMarkdownExtensions?: ToMarkdownExtension[]
+  }
+}
diff --git a/tools/ui/node_modules/remark-stringify/index.js b/tools/ui/node_modules/remark-stringify/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a4c25d60f746eac9b80f56076fa90be149881a2
--- /dev/null
+++ b/tools/ui/node_modules/remark-stringify/index.js
@@ -0,0 +1,2 @@
+// Note: types exposed from `index.d.ts`.
+export {default} from './lib/index.js'
diff --git a/tools/ui/node_modules/remark-stringify/lib/index.d.ts b/tools/ui/node_modules/remark-stringify/lib/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..881b1fafacef683cdfb62186199bdd07c7eacb13
--- /dev/null
+++ b/tools/ui/node_modules/remark-stringify/lib/index.d.ts
@@ -0,0 +1,26 @@
+/**
+ * Add support for serializing to markdown.
+ *
+ * @param {Readonly | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function remarkStringify(options?: Readonly | null | undefined): undefined;
+export default class remarkStringify {
+    /**
+     * Add support for serializing to markdown.
+     *
+     * @param {Readonly | null | undefined} [options]
+     *   Configuration (optional).
+     * @returns {undefined}
+     *   Nothing.
+     */
+    constructor(options?: Readonly | null | undefined);
+    compiler: (tree: import("mdast").Root, file: import("vfile").VFile) => string;
+}
+export type Root = import('mdast').Root;
+export type ToMarkdownOptions = import('mdast-util-to-markdown').Options;
+export type Compiler = import('unified').Compiler;
+export type Processor = import('unified').Processor;
+export type Options = Omit;
diff --git a/tools/ui/node_modules/remark-stringify/lib/index.js b/tools/ui/node_modules/remark-stringify/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1a268af0022aa78ce7bcdb6e22e432bb26e540e
--- /dev/null
+++ b/tools/ui/node_modules/remark-stringify/lib/index.js
@@ -0,0 +1,42 @@
+/**
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownOptions
+ * @typedef {import('unified').Compiler} Compiler
+ * @typedef {import('unified').Processor} Processor
+ */
+
+/**
+ * @typedef {Omit} Options
+ */
+
+import {toMarkdown} from 'mdast-util-to-markdown'
+
+/**
+ * Add support for serializing to markdown.
+ *
+ * @param {Readonly | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function remarkStringify(options) {
+  /** @type {Processor} */
+  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.
+  const self = this
+
+  self.compiler = compiler
+
+  /**
+   * @type {Compiler}
+   */
+  function compiler(tree) {
+    return toMarkdown(tree, {
+      ...self.data('settings'),
+      ...options,
+      // Note: this option is not in the readme.
+      // The goal is for it to be set by plugins on `data` instead of being
+      // passed by users.
+      extensions: self.data('toMarkdownExtensions') || []
+    })
+  }
+}
diff --git a/tools/ui/node_modules/remark-stringify/license b/tools/ui/node_modules/remark-stringify/license
new file mode 100644
index 0000000000000000000000000000000000000000..51b543068c8c0ddf05a0c35563fcfff5f6c16f8e
--- /dev/null
+++ b/tools/ui/node_modules/remark-stringify/license
@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (c) 2014 Titus Wormer 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/tools/ui/node_modules/remark-stringify/package.json b/tools/ui/node_modules/remark-stringify/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..e152a656c5e9fbee22de4e8426e1c5eeebcad1ad
--- /dev/null
+++ b/tools/ui/node_modules/remark-stringify/package.json
@@ -0,0 +1,71 @@
+{
+  "name": "remark-stringify",
+  "version": "11.0.0",
+  "description": "remark plugin to add support for serializing markdown",
+  "license": "MIT",
+  "keywords": [
+    "abstract",
+    "ast",
+    "compile",
+    "markdown",
+    "markdown",
+    "mdast",
+    "plugin",
+    "remark",
+    "remark-plugin",
+    "serialize",
+    "stringify",
+    "syntax",
+    "tree",
+    "unified"
+  ],
+  "homepage": "https://remark.js.org",
+  "repository": "https://github.com/remarkjs/remark/tree/main/packages/remark-stringify",
+  "bugs": "https://github.com/remarkjs/remark/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Titus Wormer  (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer  (https://wooorm.com)",
+    "Eugene Sharygin "
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./index.js",
+  "files": [
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "@types/mdast": "^4.0.0",
+    "mdast-util-to-markdown": "^2.0.0",
+    "unified": "^11.0.0"
+  },
+  "scripts": {},
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "ignoreCatch": true,
+    "strict": true
+  },
+  "xo": {
+    "overrides": [
+      {
+        "files": [
+          "**/*.ts"
+        ],
+        "rules": {
+          "@typescript-eslint/ban-types": "off",
+          "@typescript-eslint/consistent-type-definitions": "off"
+        }
+      }
+    ],
+    "prettier": true,
+    "rules": {
+      "unicorn/no-this-assignment": "off"
+    }
+  }
+}
diff --git a/tools/ui/node_modules/remark-stringify/readme.md b/tools/ui/node_modules/remark-stringify/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..fee71da45946a36783e1bf36e079ed64a5ce27dc
--- /dev/null
+++ b/tools/ui/node_modules/remark-stringify/readme.md
@@ -0,0 +1,407 @@
+# remark-stringify
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][sponsors-badge]][collective]
+[![Backers][backers-badge]][collective]
+[![Chat][chat-badge]][chat]
+
+**[remark][]** plugin to add support for serializing to markdown.
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When should I use this?](#when-should-i-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+    *   [`unified().use(remarkStringify[, options])`](#unifieduseremarkstringify-options)
+*   [Syntax](#syntax)
+*   [Syntax tree](#syntax-tree)
+*   [Types](#types)
+*   [Security](#security)
+*   [Contribute](#contribute)
+*   [Sponsor](#sponsor)
+*   [License](#license)
+
+## What is this?
+
+This package is a [unified][] ([remark][]) plugin that defines how to take a
+syntax tree as input and turn it into serialized markdown.
+When it’s used, markdown is serialized as the final result.
+
+See [the monorepo readme][remark] for info on what the remark ecosystem is.
+
+## When should I use this?
+
+This plugin adds support to unified for serializing markdown.
+If you also need to parse markdown, you can alternatively use
+[`remark`][remark-core], which combines unified,
+[`remark-parse`][remark-parse], and this plugin.
+
+If you don’t use plugins and have access to a syntax tree, you can directly use
+[`mdast-util-to-markdown`][mdast-util-to-markdown], which is used inside this
+plugin.
+remark focusses on making it easier to transform content by abstracting these
+internals away.
+
+You can combine this plugin with other plugins to add syntax extensions.
+Notable examples that deeply integrate with it are
+[`remark-gfm`][remark-gfm],
+[`remark-mdx`][remark-mdx],
+[`remark-frontmatter`][remark-frontmatter],
+[`remark-math`][remark-math], and
+[`remark-directive`][remark-directive].
+You can also use any other [remark plugin][remark-plugin] before
+`remark-stringify`.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install remark-stringify
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import remarkStringify from 'https://esm.sh/remark-stringify@11'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+
+```
+
+## Use
+
+Say we have the following module `example.js`:
+
+```js
+import rehypeParse from 'rehype-parse'
+import rehypeRemark from 'rehype-remark'
+import remarkStringify from 'remark-stringify'
+import {unified} from 'unified'
+
+const doc = `
+
Uranus

+
Uranus is the seventh
+planet from the Sun and is a gaseous
+cyan ice giant.

+`
+
+const file = await unified()
+  .use(rehypeParse)
+  .use(rehypeRemark)
+  .use(remarkStringify)
+  .process(doc)
+
+console.log(String(file))
+```
+
+…then running `node example.js` yields:
+
+```markdown
+# Uranus
+
+**Uranus** is the seventh [planet](/wiki/Planet "Planet") from the Sun and is a gaseous cyan [ice giant](/wiki/Ice_giant "Ice giant").
+```
+
+## API
+
+This package exports no identifiers.
+The default export is [`remarkStringify`][api-remark-stringify].
+
+### `unified().use(remarkStringify[, options])`
+
+Add support for serializing to markdown.
+
+###### Parameters
+
+*   `options` ([`Options`][api-options], optional)
+    — configuration
+
+###### Returns
+
+Nothing (`undefined`).
+
+### `Options`
+
+Configuration (TypeScript type).
+
+###### Fields
+
+*   `bullet` (`'*'`, `'+'`, or `'-'`, default: `'*'`)
+    — marker to use for bullets of items in unordered lists
+*   `bulletOther` (`'*'`, `'+'`, or `'-'`, default: `'-'` when `bullet` is
+    `'*'`, `'*'` otherwise)
+    — marker to use in certain cases where the primary bullet doesn’t work;
+    cannot be equal to `bullet`
+*   `bulletOrdered` (`'.'` or `')'`, default: `'.'`)
+    — marker to use for bullets of items in ordered lists
+*   `closeAtx` (`boolean`, default: `false`)
+    — add the same number of number signs (`#`) at the end of an ATX heading as
+    the opening sequence
+*   `emphasis` (`'*'` or `'_'`, default: `'*'`)
+    — marker to use for emphasis
+*   `fence` (``'`'`` or `'~'`, default: ``'`'``)
+    — marker to use for fenced code
+*   `fences` (`boolean`, default: `true`)
+    — use fenced code always; when `false`, uses fenced code if there is a
+    language defined, if the code is empty, or if it starts or ends in blank
+    lines
+*   `handlers` (`Handlers`, optional)
+    — handle particular nodes;
+    see [`mdast-util-to-markdown`][mdast-util-to-markdown] for more info
+*   `incrementListMarker` (`boolean`, default: `true`)
+    — increment the counter of ordered lists items
+*   `join` (`Array`, optional)
+    — how to join blocks;
+    see [`mdast-util-to-markdown`][mdast-util-to-markdown] for more info
+*   `listItemIndent` (`'mixed'`, `'one'`, or `'tab'`, default: `'one'`)
+    — how to indent the content of list items;
+    either with the size of the bullet plus one space (when `'one'`), a tab
+    stop (`'tab'`), or depending on the item and its parent list: `'mixed'`
+    uses `'one'` if the item and list are tight and `'tab'` otherwise
+*   `quote` (`'"'` or `"'"`, default: `'"'`)
+    — marker to use for titles
+*   `resourceLink` (`boolean`, default: `false`)
+    — always use resource links (`[text](url)`);
+    when `false`, uses autolinks (``) when possible
+*   `rule` (`'*'`, `'-'`, or `'_'`, default: `'*'`)
+    — marker to use for thematic breaks
+*   `ruleRepetition` (`number`, default: `3`, min: `3`)
+    — number of markers to use for thematic breaks
+*   `ruleSpaces` (`boolean`, default: `false`)
+    — add spaces between markers in thematic breaks
+*   `setext` (`boolean`, default: `false`)
+    — use setext headings when possible;
+    when `true`, uses setext headings (`heading\n=======`) for non-empty rank 1
+    or 2 headings
+*   `strong` (`'*'` or `'_'`, default: `'*'`)
+    — marker to use for strong
+*   `tightDefinitions` (`boolean`, default: `false`)
+    — join definitions without a blank line
+*   `unsafe` (`Array`, optional)
+    — schemas that define when characters cannot occur;
+    see [`mdast-util-to-markdown`][mdast-util-to-markdown] for more info
+
+
+
+## Syntax
+
+Markdown is serialized according to CommonMark but care is taken to format in a
+way that works with most markdown parsers.
+Other plugins can add support for syntax extensions.
+
+## Syntax tree
+
+The syntax tree used in remark is [mdast][].
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional type [`Options`][api-options].
+
+It also registers `Settings` with `unified`.
+If you’re passing options with `.data('settings', …)`, make sure to import this
+package somewhere in your types, as that registers the fields.
+
+```js
+/// 
+
+import {unified} from 'unified'
+
+// @ts-expect-error: `thisDoesNotExist` is not a valid option.
+unified().data('settings', {thisDoesNotExist: false})
+```
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line, `remark-stringify@^11`,
+compatible with Node.js 16.
+
+## Security
+
+Use of `remark-stringify` is safe.
+
+Use of remark plugins can open you up to attacks.
+Carefully assess each plugin and the risks involved in using them.
+
+For info on how to submit a report, see our [security policy][security].
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`remarkjs/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+Join us in [Discussions][chat] to chat with the community and contributors.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## Sponsor
+
+Support this effort and give back by sponsoring on [OpenCollective][collective]!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+  Vercel


+  
+		
+  Motif


+  
+		
+  HashiCorp


+  
+		
+  GitBook


+  
+		
+  Gatsby


+  
+

+  Netlify


+  
+  
+		
+  Coinbase


+  
+		
+  ThemeIsle


+  
+		
+  Expo


+  
+		
+  Boost Note


+  
+		
+  Markdown Space


+  
+		
+  Holloway


+  
+

+  

+  You?
+  


+

+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+
+
+[build-badge]: https://github.com/remarkjs/remark/workflows/main/badge.svg
+
+[build]: https://github.com/remarkjs/remark/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/remarkjs/remark.svg
+
+[coverage]: https://codecov.io/github/remarkjs/remark
+
+[downloads-badge]: https://img.shields.io/npm/dm/remark-stringify.svg
+
+[downloads]: https://www.npmjs.com/package/remark-stringify
+
+[size-badge]: https://img.shields.io/bundlejs/size/remark-stringify
+
+[size]: https://bundlejs.com/?q=remark-stringify
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[collective]: https://opencollective.com/unified
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/remarkjs/remark/discussions
+
+[security]: https://github.com/remarkjs/.github/blob/main/security.md
+
+[health]: https://github.com/remarkjs/.github
+
+[contributing]: https://github.com/remarkjs/.github/blob/main/contributing.md
+
+[support]: https://github.com/remarkjs/.github/blob/main/support.md
+
+[coc]: https://github.com/remarkjs/.github/blob/main/code-of-conduct.md
+
+[license]: https://github.com/remarkjs/remark/blob/main/license
+
+[author]: https://wooorm.com
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[mdast]: https://github.com/syntax-tree/mdast
+
+[mdast-util-to-markdown]: https://github.com/syntax-tree/mdast-util-to-markdown
+
+[remark]: https://github.com/remarkjs/remark
+
+[remark-core]: ../remark/
+
+[remark-directive]: https://github.com/remarkjs/remark-directive
+
+[remark-frontmatter]: https://github.com/remarkjs/remark-frontmatter
+
+[remark-gfm]: https://github.com/remarkjs/remark-gfm
+
+[remark-math]: https://github.com/remarkjs/remark-math
+
+[remark-mdx]: https://github.com/mdx-js/mdx/tree/main/packages/remark-mdx
+
+[remark-parse]: ../remark-parse/
+
+[remark-plugin]: https://github.com/remarkjs/remark#plugin
+
+[typescript]: https://www.typescriptlang.org
+
+[unified]: https://github.com/unifiedjs/unified
+
+[api-options]: #options
+
+[api-remark-stringify]: #unifieduseremarkstringify-options
diff --git a/tools/ui/node_modules/remark/index.d.ts b/tools/ui/node_modules/remark/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0feb85d04dbd99f2cfddbb98fbe4575dbb92fa7d
--- /dev/null
+++ b/tools/ui/node_modules/remark/index.d.ts
@@ -0,0 +1,11 @@
+/// 
+/// 
+
+import type {Root} from 'mdast'
+import type {Processor} from 'unified'
+
+/**
+ * Create a new unified processor that already uses `remark-parse` and
+ * `remark-stringify`.
+ */
+export const remark: Processor
diff --git a/tools/ui/node_modules/remark/index.js b/tools/ui/node_modules/remark/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..5cca37688b75de4b43f949981bb82b8a68729f8a
--- /dev/null
+++ b/tools/ui/node_modules/remark/index.js
@@ -0,0 +1,10 @@
+// Note: types exposed from `index.d.ts`
+import remarkParse from 'remark-parse'
+import remarkStringify from 'remark-stringify'
+import {unified} from 'unified'
+
+/**
+ * Create a new unified processor that already uses `remark-parse` and
+ * `remark-stringify`.
+ */
+export const remark = unified().use(remarkParse).use(remarkStringify).freeze()
diff --git a/tools/ui/node_modules/remark/license b/tools/ui/node_modules/remark/license
new file mode 100644
index 0000000000000000000000000000000000000000..51b543068c8c0ddf05a0c35563fcfff5f6c16f8e
--- /dev/null
+++ b/tools/ui/node_modules/remark/license
@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (c) 2014 Titus Wormer 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/tools/ui/node_modules/remark/package.json b/tools/ui/node_modules/remark/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..3741c66cb8b822e7685ad2f8a553aba22eda22c4
--- /dev/null
+++ b/tools/ui/node_modules/remark/package.json
@@ -0,0 +1,65 @@
+{
+  "name": "remark",
+  "version": "15.0.1",
+  "description": "markdown processor powered by plugins part of the unified collective",
+  "license": "MIT",
+  "keywords": [
+    "abstract",
+    "ast",
+    "compile",
+    "markdown",
+    "mdast",
+    "parse",
+    "process",
+    "remark",
+    "serialize",
+    "stringify",
+    "syntax",
+    "tree",
+    "unified"
+  ],
+  "homepage": "https://remark.js.org",
+  "repository": "https://github.com/remarkjs/remark/tree/main/packages/remark",
+  "bugs": "https://github.com/remarkjs/remark/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Titus Wormer  (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer  (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./index.js",
+  "files": [
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "@types/mdast": "^4.0.0",
+    "remark-parse": "^11.0.0",
+    "remark-stringify": "^11.0.0",
+    "unified": "^11.0.0"
+  },
+  "scripts": {},
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "ignoreCatch": true,
+    "strict": true
+  },
+  "xo": {
+    "overrides": [
+      {
+        "files": [
+          "**/*.ts"
+        ],
+        "rules": {
+          "@typescript-eslint/triple-slash-reference": "off"
+        }
+      }
+    ],
+    "prettier": true
+  }
+}
diff --git a/tools/ui/node_modules/remark/readme.md b/tools/ui/node_modules/remark/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..649053ae6ae87da42f0109f0c2912dca21d63b0e
--- /dev/null
+++ b/tools/ui/node_modules/remark/readme.md
@@ -0,0 +1,443 @@
+# remark
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][sponsors-badge]][collective]
+[![Backers][backers-badge]][collective]
+[![Chat][chat-badge]][chat]
+
+**[unified][]** processor with support for parsing from markdown and
+serializing to markdown.
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When should I use this?](#when-should-i-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+    *   [`remark()`](#remark-1)
+*   [Examples](#examples)
+    *   [Example: checking markdown](#example-checking-markdown)
+    *   [Example: passing options to `remark-stringify`](#example-passing-options-to-remark-stringify)
+*   [Syntax](#syntax)
+*   [Syntax tree](#syntax-tree)
+*   [Types](#types)
+*   [Compatibility](#compatibility)
+*   [Security](#security)
+*   [Contribute](#contribute)
+*   [Sponsor](#sponsor)
+*   [License](#license)
+
+## What is this?
+
+This package is a [unified][] processor with support for parsing markdown as
+input and serializing markdown as output by using unified with
+[`remark-parse`][remark-parse] and [`remark-stringify`][remark-stringify].
+
+See [the monorepo readme][remark] for info on what the remark ecosystem is.
+
+## When should I use this?
+
+You can use this package when you want to use unified, have markdown as input,
+and want markdown as output.
+This package is a shortcut for
+`unified().use(remarkParse).use(remarkStringify)`.
+When the input isn’t markdown (meaning you don’t need `remark-parse`) or the
+output is not markdown (you don’t need `remark-stringify`), it’s recommended to
+use `unified` directly.
+
+When you want to inspect and format markdown files in a project on the command
+line, you can use [`remark-cli`][remark-cli].
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install remark
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import {remark} from 'https://esm.sh/remark@15'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+
+```
+
+## Use
+
+Say we have the following module `example.js`:
+
+```js
+import {remark} from 'remark'
+import remarkToc from 'remark-toc'
+
+const doc = `
+# Pluto
+
+Pluto is a dwarf planet in the Kuiper belt.
+
+## Contents
+
+## History
+
+### Discovery
+
+In the 1840s, Urbain Le Verrier used Newtonian mechanics to predict the position of…
+
+### Name and symbol
+
+The name Pluto is for the Roman god of the underworld, from a Greek epithet for Hades…
+
+### Planet X disproved
+
+Once Pluto was found, its faintness and lack of a viewable disc cast doubt…
+
+## Orbit
+
+Pluto's orbital period is about 248 years…
+`
+
+const file = await remark()
+  .use(remarkToc, {heading: 'contents', tight: true})
+  .process(doc)
+
+console.error(String(file))
+```
+
+…running that with `node example.js` yields:
+
+```markdown
+# Pluto
+
+Pluto is a dwarf planet in the Kuiper belt.
+
+## Contents
+
+* [History](#history)
+  * [Discovery](#discovery)
+  * [Name and symbol](#name-and-symbol)
+  * [Planet X disproved](#planet-x-disproved)
+* [Orbit](#orbit)
+
+## History
+
+### Discovery
+
+In the 1840s, Urbain Le Verrier used Newtonian mechanics to predict the position of…
+
+### Name and symbol
+
+The name Pluto is for the Roman god of the underworld, from a Greek epithet for Hades…
+
+### Planet X disproved
+
+Once Pluto was found, its faintness and lack of a viewable disc cast doubt…
+
+## Orbit
+
+Pluto's orbital period is about 248 years…
+```
+
+## API
+
+This package exports the identifier [`remark`][api-remark].
+There is no default export.
+
+### `remark()`
+
+Create a new unified processor that already uses
+[`remark-parse`][remark-parse] and [`remark-stringify`][remark-stringify].
+
+You can add more plugins with `use`.
+See [`unified`][unified] for more information.
+
+## Examples
+
+### Example: checking markdown
+
+The following example checks that markdown code style is consistent and follows
+some best practices:
+
+```js
+import {remark} from 'remark'
+import remarkPresetLintConsistent from 'remark-preset-lint-consistent'
+import remarkPresetLintRecommended from 'remark-preset-lint-recommended'
+import {reporter} from 'vfile-reporter'
+
+const file = await remark()
+  .use(remarkPresetLintConsistent)
+  .use(remarkPresetLintRecommended)
+  .process('1) Hello, _Jupiter_ and *Neptune*!')
+
+console.error(reporter(file))
+```
+
+Yields:
+
+```txt
+          warning Missing newline character at end of file final-newline             remark-lint
+1:1-1:35  warning Marker style should be `.`               ordered-list-marker-style remark-lint
+1:4       warning Incorrect list-item indent: add 1 space  list-item-indent          remark-lint
+1:25-1:34 warning Emphasis should use `_` as a marker      emphasis-marker           remark-lint
+
+⚠ 4 warnings
+```
+
+### Example: passing options to `remark-stringify`
+
+When you use `remark-stringify` manually you can pass options to `use`.
+Because `remark-stringify` is already used in `remark`, that’s not possible.
+To define options for `remark-stringify`, you can instead pass options to
+`data`:
+
+```js
+import {remark} from 'remark'
+
+const doc = `
+# Moons of Neptune
+
+1. Naiad
+2. Thalassa
+3. Despine
+4. …
+`
+
+const file = await remark()
+  .data('settings', {
+    bulletOrdered: ')',
+    incrementListMarker: false,
+    setext: true
+  })
+  .process(doc)
+
+console.log(String(file))
+```
+
+Yields:
+
+```markdown
+Moons of Neptune
+================
+
+1) Naiad
+1) Thalassa
+1) Despine
+1) …
+```
+
+## Syntax
+
+Markdown is parsed and serialized according to CommonMark.
+Other plugins can add support for syntax extensions.
+
+## Syntax tree
+
+The syntax tree used in remark is [mdast][].
+
+## Types
+
+This package is fully typed with [TypeScript][].
+There are no extra exported types.
+
+It also registers `Settings` with `unified`.
+If you’re passing options with `.data('settings', …)`, make sure to import this
+package somewhere in your types, as that registers the fields.
+
+```js
+/// 
+
+import {unified} from 'unified'
+
+// @ts-expect-error: `thisDoesNotExist` is not a valid option.
+unified().data('settings', {thisDoesNotExist: false})
+```
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line, `remark@^15`, compatible
+with Node.js 16.
+
+## Security
+
+As markdown can be turned into HTML and improper use of HTML can open you up to
+[cross-site scripting (XSS)][xss] attacks, use of remark can be unsafe.
+When going to HTML, you will combine remark with **[rehype][]**, in which case
+you should use [`rehype-sanitize`][rehype-sanitize].
+
+Use of remark plugins could also open you up to other attacks.
+Carefully assess each plugin and the risks involved in using them.
+
+For info on how to submit a report, see our [security policy][security].
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`remarkjs/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+Join us in [Discussions][chat] to chat with the community and contributors.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## Sponsor
+
+Support this effort and give back by sponsoring on [OpenCollective][collective]!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+  Vercel


+  
+		
+  Motif


+  
+		
+  HashiCorp


+  
+		
+  GitBook


+  
+		
+  Gatsby


+  
+

+  Netlify


+  
+  
+		
+  Coinbase


+  
+		
+  ThemeIsle


+  
+		
+  Expo


+  
+		
+  Boost Note


+  
+		
+  Markdown Space


+  
+		
+  Holloway


+  
+

+  

+  You?
+  


+

+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+
+
+[build-badge]: https://github.com/remarkjs/remark/workflows/main/badge.svg
+
+[build]: https://github.com/remarkjs/remark/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/remarkjs/remark.svg
+
+[coverage]: https://codecov.io/github/remarkjs/remark
+
+[downloads-badge]: https://img.shields.io/npm/dm/remark.svg
+
+[downloads]: https://www.npmjs.com/package/remark
+
+[size-badge]: https://img.shields.io/bundlejs/size/remark
+
+[size]: https://bundlejs.com/?q=remark
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[collective]: https://opencollective.com/unified
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/remarkjs/remark/discussions
+
+[security]: https://github.com/remarkjs/.github/blob/main/security.md
+
+[health]: https://github.com/remarkjs/.github
+
+[contributing]: https://github.com/remarkjs/.github/blob/main/contributing.md
+
+[support]: https://github.com/remarkjs/.github/blob/main/support.md
+
+[coc]: https://github.com/remarkjs/.github/blob/main/code-of-conduct.md
+
+[license]: https://github.com/remarkjs/remark/blob/main/license
+
+[author]: https://wooorm.com
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[mdast]: https://github.com/syntax-tree/mdast
+
+[rehype]: https://github.com/rehypejs/rehype
+
+[rehype-sanitize]: https://github.com/rehypejs/rehype-sanitize
+
+[remark]: https://github.com/remarkjs/remark
+
+[remark-parse]: ../remark-parse
+
+[remark-stringify]: ../remark-stringify
+
+[remark-cli]: ../remark-cli
+
+[typescript]: https://www.typescriptlang.org
+
+[unified]: https://github.com/unifiedjs/unified
+
+[xss]: https://en.wikipedia.org/wiki/Cross-site_scripting
+
+[api-remark]: #remark-1
diff --git a/tools/ui/node_modules/require-from-string/index.js b/tools/ui/node_modules/require-from-string/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb5595fde96fbb91b5267aad801b64adbbf3e336
--- /dev/null
+++ b/tools/ui/node_modules/require-from-string/index.js
@@ -0,0 +1,34 @@
+'use strict';
+
+var Module = require('module');
+var path = require('path');
+
+module.exports = function requireFromString(code, filename, opts) {
+	if (typeof filename === 'object') {
+		opts = filename;
+		filename = undefined;
+	}
+
+	opts = opts || {};
+	filename = filename || '';
+
+	opts.appendPaths = opts.appendPaths || [];
+	opts.prependPaths = opts.prependPaths || [];
+
+	if (typeof code !== 'string') {
+		throw new Error('code must be a string, not ' + typeof code);
+	}
+
+	var paths = Module._nodeModulePaths(path.dirname(filename));
+
+	var parent = module.parent;
+	var m = new Module(filename, parent);
+	m.filename = filename;
+	m.paths = [].concat(opts.prependPaths).concat(paths).concat(opts.appendPaths);
+	m._compile(code, filename);
+
+	var exports = m.exports;
+	parent && parent.children && parent.children.splice(parent.children.indexOf(m), 1);
+
+	return exports;
+};
diff --git a/tools/ui/node_modules/require-from-string/license b/tools/ui/node_modules/require-from-string/license
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb74fd25e1715d8129a1babc8113f7c4deb7e3
--- /dev/null
+++ b/tools/ui/node_modules/require-from-string/license
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Vsevolod Strukchinsky  (github.com/floatdrop)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/tools/ui/node_modules/require-from-string/package.json b/tools/ui/node_modules/require-from-string/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..800d46efcb00b34819a82f9ca807233f71a5fcb5
--- /dev/null
+++ b/tools/ui/node_modules/require-from-string/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "require-from-string",
+  "version": "2.0.2",
+  "description": "Require module from string",
+  "license": "MIT",
+  "repository": "floatdrop/require-from-string",
+  "author": {
+    "name": "Vsevolod Strukchinsky",
+    "email": "floatdrop@gmail.com",
+    "url": "github.com/floatdrop"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "files": [
+    "index.js"
+  ],
+  "keywords": [
+    ""
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "mocha": "*"
+  }
+}
diff --git a/tools/ui/node_modules/require-from-string/readme.md b/tools/ui/node_modules/require-from-string/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..88b3236f895d369a22e84d2df206d59e55a01821
--- /dev/null
+++ b/tools/ui/node_modules/require-from-string/readme.md
@@ -0,0 +1,56 @@
+# require-from-string [![Build Status](https://travis-ci.org/floatdrop/require-from-string.svg?branch=master)](https://travis-ci.org/floatdrop/require-from-string)
+
+Load module from string in Node.
+
+## Install
+
+```
+$ npm install --save require-from-string
+```
+
+
+## Usage
+
+```js
+var requireFromString = require('require-from-string');
+
+requireFromString('module.exports = 1');
+//=> 1
+```
+
+
+## API
+
+### requireFromString(code, [filename], [options])
+
+#### code
+
+*Required*  
+Type: `string`
+
+Module code.
+
+#### filename
+Type: `string`  
+Default: `''`
+
+Optional filename.
+
+
+#### options
+Type: `object`
+
+##### appendPaths
+Type: `Array`
+
+List of `paths`, that will be appended to module `paths`. Useful, when you want
+to be able require modules from these paths.
+
+##### prependPaths
+Type: `Array`
+
+Same as `appendPaths`, but paths will be prepended.
+
+## License
+
+MIT © [Vsevolod Strukchinsky](http://github.com/floatdrop)
diff --git a/tools/ui/node_modules/requires-port/.npmignore b/tools/ui/node_modules/requires-port/.npmignore
new file mode 100644
index 0000000000000000000000000000000000000000..ba2a97b57acafe13673b76a624a59ebceadb2849
--- /dev/null
+++ b/tools/ui/node_modules/requires-port/.npmignore
@@ -0,0 +1,2 @@
+node_modules
+coverage
diff --git a/tools/ui/node_modules/requires-port/.travis.yml b/tools/ui/node_modules/requires-port/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..0765106aba166102062bae3d2a1f6fe518f69ccf
--- /dev/null
+++ b/tools/ui/node_modules/requires-port/.travis.yml
@@ -0,0 +1,19 @@
+sudo: false
+language: node_js
+node_js:
+  - "4"
+  - "iojs"
+  - "0.12"
+  - "0.10"
+script:
+  - "npm run test-travis"
+after_script:
+  - "npm install coveralls@2 && cat coverage/lcov.info | coveralls"
+matrix:
+  fast_finish: true
+notifications:
+  irc:
+    channels:
+      - "irc.freenode.org#unshift"
+    on_success: change
+    on_failure: change
diff --git a/tools/ui/node_modules/requires-port/LICENSE b/tools/ui/node_modules/requires-port/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..6dc9316a6c92f2782c0bcf29951bf2a704524277
--- /dev/null
+++ b/tools/ui/node_modules/requires-port/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Unshift.io, Arnout Kazemier,  the Contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/tools/ui/node_modules/requires-port/README.md b/tools/ui/node_modules/requires-port/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..3effe759703730dc1df39b012c03727b9e641abf
--- /dev/null
+++ b/tools/ui/node_modules/requires-port/README.md
@@ -0,0 +1,47 @@
+# requires-port
+
+[![Made by unshift](https://img.shields.io/badge/made%20by-unshift-00ffcc.svg?style=flat-square)](http://unshift.io)[![Version npm](http://img.shields.io/npm/v/requires-port.svg?style=flat-square)](http://browsenpm.org/package/requires-port)[![Build Status](http://img.shields.io/travis/unshiftio/requires-port/master.svg?style=flat-square)](https://travis-ci.org/unshiftio/requires-port)[![Dependencies](https://img.shields.io/david/unshiftio/requires-port.svg?style=flat-square)](https://david-dm.org/unshiftio/requires-port)[![Coverage Status](http://img.shields.io/coveralls/unshiftio/requires-port/master.svg?style=flat-square)](https://coveralls.io/r/unshiftio/requires-port?branch=master)[![IRC channel](http://img.shields.io/badge/IRC-irc.freenode.net%23unshift-00a8ff.svg?style=flat-square)](http://webchat.freenode.net/?channels=unshift)
+
+The module name says it all, check if a protocol requires a given port.
+
+## Installation
+
+This module is intended to be used with browserify or Node.js and is distributed
+in the public npm registry. To install it simply run the following command from
+your CLI:
+
+```j
+npm install --save requires-port
+```
+
+## Usage
+
+The module exports it self as function and requires 2 arguments:
+
+1. The port number, can be a string or number.
+2. Protocol, can be `http`, `http:` or even `https://yomoma.com`. We just split
+   it at `:` and use the first result. We currently accept the following
+   protocols:
+   - `http`
+   - `https`
+   - `ws`
+   - `wss`
+   - `ftp`
+   - `gopher`
+   - `file`
+
+It returns a boolean that indicates if protocol requires this port to be added
+to your URL.
+
+```js
+'use strict';
+
+var required = require('requires-port');
+
+console.log(required('8080', 'http')) // true
+console.log(required('80', 'http'))   // false
+```
+
+# License
+
+MIT
diff --git a/tools/ui/node_modules/requires-port/index.js b/tools/ui/node_modules/requires-port/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..4f267b26c7284dd94e97950aa32e087cb159887d
--- /dev/null
+++ b/tools/ui/node_modules/requires-port/index.js
@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * Check if we're required to add a port number.
+ *
+ * @see https://url.spec.whatwg.org/#default-port
+ * @param {Number|String} port Port number we need to check
+ * @param {String} protocol Protocol we need to check against.
+ * @returns {Boolean} Is it a default port for the given protocol
+ * @api private
+ */
+module.exports = function required(port, protocol) {
+  protocol = protocol.split(':')[0];
+  port = +port;
+
+  if (!port) return false;
+
+  switch (protocol) {
+    case 'http':
+    case 'ws':
+    return port !== 80;
+
+    case 'https':
+    case 'wss':
+    return port !== 443;
+
+    case 'ftp':
+    return port !== 21;
+
+    case 'gopher':
+    return port !== 70;
+
+    case 'file':
+    return false;
+  }
+
+  return port !== 0;
+};
diff --git a/tools/ui/node_modules/requires-port/package.json b/tools/ui/node_modules/requires-port/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..c113b4bf78f20e5fdbb458e97131047b557f02d8
--- /dev/null
+++ b/tools/ui/node_modules/requires-port/package.json
@@ -0,0 +1,47 @@
+{
+  "name": "requires-port",
+  "version": "1.0.0",
+  "description": "Check if a protocol requires a certain port number to be added to an URL.",
+  "main": "index.js",
+  "scripts": {
+    "100%": "istanbul check-coverage --statements 100 --functions 100 --lines 100 --branches 100",
+    "test-travis": "istanbul cover _mocha --report lcovonly -- test.js",
+    "coverage": "istanbul cover _mocha -- test.js",
+    "watch": "mocha --watch test.js",
+    "test": "mocha test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/unshiftio/requires-port"
+  },
+  "keywords": [
+    "port",
+    "require",
+    "http",
+    "https",
+    "ws",
+    "wss",
+    "gopher",
+    "file",
+    "ftp",
+    "requires",
+    "requried",
+    "portnumber",
+    "url",
+    "parsing",
+    "validation",
+    "cows"
+  ],
+  "author": "Arnout Kazemier",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/unshiftio/requires-port/issues"
+  },
+  "homepage": "https://github.com/unshiftio/requires-port",
+  "devDependencies": {
+    "assume": "1.3.x",
+    "istanbul": "0.4.x",
+    "mocha": "2.3.x",
+    "pre-commit": "1.1.x"
+  }
+}
diff --git a/tools/ui/node_modules/requires-port/test.js b/tools/ui/node_modules/requires-port/test.js
new file mode 100644
index 0000000000000000000000000000000000000000..93a0c749809a72a4c302436b300666af45c6a4bc
--- /dev/null
+++ b/tools/ui/node_modules/requires-port/test.js
@@ -0,0 +1,98 @@
+describe('requires-port', function () {
+  'use strict';
+
+  var assume = require('assume')
+    , required = require('./');
+
+  it('is exported as a function', function () {
+    assume(required).is.a('function');
+  });
+
+  it('does not require empty ports', function () {
+    assume(required('', 'http')).false();
+    assume(required('', 'wss')).false();
+    assume(required('', 'ws')).false();
+    assume(required('', 'cowsack')).false();
+  });
+
+  it('assumes true for unknown protocols',function () {
+    assume(required('808', 'foo')).true();
+    assume(required('80', 'bar')).true();
+  });
+
+  it('never requires port numbers for file', function () {
+    assume(required(8080, 'file')).false();
+  });
+
+  it('does not require port 80 for http', function () {
+    assume(required('80', 'http')).false();
+    assume(required(80, 'http')).false();
+    assume(required(80, 'http://')).false();
+    assume(required(80, 'http://www.google.com')).false();
+
+    assume(required('8080', 'http')).true();
+    assume(required(8080, 'http')).true();
+    assume(required(8080, 'http://')).true();
+    assume(required(8080, 'http://www.google.com')).true();
+  });
+
+  it('does not require port 80 for ws', function () {
+    assume(required('80', 'ws')).false();
+    assume(required(80, 'ws')).false();
+    assume(required(80, 'ws://')).false();
+    assume(required(80, 'ws://www.google.com')).false();
+
+    assume(required('8080', 'ws')).true();
+    assume(required(8080, 'ws')).true();
+    assume(required(8080, 'ws://')).true();
+    assume(required(8080, 'ws://www.google.com')).true();
+  });
+
+  it('does not require port 443 for https', function () {
+    assume(required('443', 'https')).false();
+    assume(required(443, 'https')).false();
+    assume(required(443, 'https://')).false();
+    assume(required(443, 'https://www.google.com')).false();
+
+    assume(required('8080', 'https')).true();
+    assume(required(8080, 'https')).true();
+    assume(required(8080, 'https://')).true();
+    assume(required(8080, 'https://www.google.com')).true();
+  });
+
+  it('does not require port 443 for wss', function () {
+    assume(required('443', 'wss')).false();
+    assume(required(443, 'wss')).false();
+    assume(required(443, 'wss://')).false();
+    assume(required(443, 'wss://www.google.com')).false();
+
+    assume(required('8080', 'wss')).true();
+    assume(required(8080, 'wss')).true();
+    assume(required(8080, 'wss://')).true();
+    assume(required(8080, 'wss://www.google.com')).true();
+  });
+
+  it('does not require port 21 for ftp', function () {
+    assume(required('21', 'ftp')).false();
+    assume(required(21, 'ftp')).false();
+    assume(required(21, 'ftp://')).false();
+    assume(required(21, 'ftp://www.google.com')).false();
+
+    assume(required('8080', 'ftp')).true();
+    assume(required(8080, 'ftp')).true();
+    assume(required(8080, 'ftp://')).true();
+    assume(required(8080, 'ftp://www.google.com')).true();
+  });
+
+  it('does not require port 70 for gopher', function () {
+    assume(required('70', 'gopher')).false();
+    assume(required(70, 'gopher')).false();
+    assume(required(70, 'gopher://')).false();
+    assume(required(70, 'gopher://www.google.com')).false();
+
+    assume(required('8080', 'gopher')).true();
+    assume(required(8080, 'gopher')).true();
+    assume(required(8080, 'gopher://')).true();
+    assume(required(8080, 'gopher://www.google.com')).true();
+  });
+});
diff --git a/tools/ui/node_modules/resolve-from/index.js b/tools/ui/node_modules/resolve-from/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..d092447e9945c4738d90e10b31552e55498dda47
--- /dev/null
+++ b/tools/ui/node_modules/resolve-from/index.js
@@ -0,0 +1,47 @@
+'use strict';
+const path = require('path');
+const Module = require('module');
+const fs = require('fs');
+
+const resolveFrom = (fromDir, moduleId, silent) => {
+	if (typeof fromDir !== 'string') {
+		throw new TypeError(`Expected \`fromDir\` to be of type \`string\`, got \`${typeof fromDir}\``);
+	}
+
+	if (typeof moduleId !== 'string') {
+		throw new TypeError(`Expected \`moduleId\` to be of type \`string\`, got \`${typeof moduleId}\``);
+	}
+
+	try {
+		fromDir = fs.realpathSync(fromDir);
+	} catch (err) {
+		if (err.code === 'ENOENT') {
+			fromDir = path.resolve(fromDir);
+		} else if (silent) {
+			return null;
+		} else {
+			throw err;
+		}
+	}
+
+	const fromFile = path.join(fromDir, 'noop.js');
+
+	const resolveFileName = () => Module._resolveFilename(moduleId, {
+		id: fromFile,
+		filename: fromFile,
+		paths: Module._nodeModulePaths(fromDir)
+	});
+
+	if (silent) {
+		try {
+			return resolveFileName();
+		} catch (err) {
+			return null;
+		}
+	}
+
+	return resolveFileName();
+};
+
+module.exports = (fromDir, moduleId) => resolveFrom(fromDir, moduleId);
+module.exports.silent = (fromDir, moduleId) => resolveFrom(fromDir, moduleId, true);
diff --git a/tools/ui/node_modules/resolve-from/license b/tools/ui/node_modules/resolve-from/license
new file mode 100644
index 0000000000000000000000000000000000000000..e7af2f77107d73046421ef56c4684cbfdd3c1e89
--- /dev/null
+++ b/tools/ui/node_modules/resolve-from/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus  (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/tools/ui/node_modules/resolve-from/package.json b/tools/ui/node_modules/resolve-from/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..96bade58824569002af01fce2462aa0d4f8a1035
--- /dev/null
+++ b/tools/ui/node_modules/resolve-from/package.json
@@ -0,0 +1,34 @@
+{
+	"name": "resolve-from",
+	"version": "4.0.0",
+	"description": "Resolve the path of a module like `require.resolve()` but from a given path",
+	"license": "MIT",
+	"repository": "sindresorhus/resolve-from",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=4"
+	},
+	"scripts": {
+		"test": "xo && ava"
+	},
+	"files": [
+		"index.js"
+	],
+	"keywords": [
+		"require",
+		"resolve",
+		"path",
+		"module",
+		"from",
+		"like",
+		"import"
+	],
+	"devDependencies": {
+		"ava": "*",
+		"xo": "*"
+	}
+}
diff --git a/tools/ui/node_modules/resolve-from/readme.md b/tools/ui/node_modules/resolve-from/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..e539f858ef45d9073adddfe2228bafc77f7f05fe
--- /dev/null
+++ b/tools/ui/node_modules/resolve-from/readme.md
@@ -0,0 +1,72 @@
+# resolve-from [![Build Status](https://travis-ci.org/sindresorhus/resolve-from.svg?branch=master)](https://travis-ci.org/sindresorhus/resolve-from)
+
+> Resolve the path of a module like [`require.resolve()`](https://nodejs.org/api/globals.html#globals_require_resolve) but from a given path
+
+
+## Install
+
+```
+$ npm install resolve-from
+```
+
+
+## Usage
+
+```js
+const resolveFrom = require('resolve-from');
+
+// There is a file at `./foo/bar.js`
+
+resolveFrom('foo', './bar');
+//=> '/Users/sindresorhus/dev/test/foo/bar.js'
+```
+
+
+## API
+
+### resolveFrom(fromDir, moduleId)
+
+Like `require()`, throws when the module can't be found.
+
+### resolveFrom.silent(fromDir, moduleId)
+
+Returns `null` instead of throwing when the module can't be found.
+
+#### fromDir
+
+Type: `string`
+
+Directory to resolve from.
+
+#### moduleId
+
+Type: `string`
+
+What you would use in `require()`.
+
+
+## Tip
+
+Create a partial using a bound function if you want to resolve from the same `fromDir` multiple times:
+
+```js
+const resolveFromFoo = resolveFrom.bind(null, 'foo');
+
+resolveFromFoo('./bar');
+resolveFromFoo('./baz');
+```
+
+
+## Related
+
+- [resolve-cwd](https://github.com/sindresorhus/resolve-cwd) - Resolve the path of a module from the current working directory
+- [import-from](https://github.com/sindresorhus/import-from) - Import a module from a given path
+- [import-cwd](https://github.com/sindresorhus/import-cwd) - Import a module from the current working directory
+- [resolve-pkg](https://github.com/sindresorhus/resolve-pkg) - Resolve the path of a package regardless of it having an entry point
+- [import-lazy](https://github.com/sindresorhus/import-lazy) - Import a module lazily
+- [resolve-global](https://github.com/sindresorhus/resolve-global) - Resolve the path of a globally installed module
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)
diff --git a/tools/ui/node_modules/resolve/.claude/notes.md b/tools/ui/node_modules/resolve/.claude/notes.md
new file mode 100644
index 0000000000000000000000000000000000000000..2211f0abee3821a039e4e6eca6bd3c49357225d4
--- /dev/null
+++ b/tools/ui/node_modules/resolve/.claude/notes.md
@@ -0,0 +1,26 @@
+# resolve package - session notes
+
+## Versioning
+- Manual versioning only - do NOT use `npm version`
+- Edit package.json version directly, commit with message `v{version}`, then create annotated tag
+- Changelog lives in git tag annotations, not a separate file
+- Tag format: `git tag -a v{version} -m "{changelog}"`
+
+## Code style
+- `__proto__: null` on ALL object literals (prototype pollution protection)
+- `.slice()` not `.substring()`
+- One exported function per file
+- Move nested/inner functions to module level when feasible
+- Prefer non-hoisted declarations (function declarations at module level, not expressions)
+- No mutation - copy objects instead of modifying inputs
+
+## Testing
+- `test/list-exports` is a git submodule with sparse checkout
+- Tests should cover ALL entrypoints from fixtures, not just `'.'` subpaths
+- Use `extensions: ['.js', '.json']` when testing exports resolution
+
+## exports field implementation
+- Uses `node-exports-info` for category semantics
+- Categories: pre-exports, broken, conditions, patterns, pattern-trailers, current
+- `exportsCategory` option or `engines: true` to auto-detect from consumer's engines.node
+- Self-reference resolution respects node_modules boundaries
diff --git a/tools/ui/node_modules/resolve/.claude/settings.local.json b/tools/ui/node_modules/resolve/.claude/settings.local.json
new file mode 100644
index 0000000000000000000000000000000000000000..5a3a5071e447f58b7b05c0b13760763be1ec711a
--- /dev/null
+++ b/tools/ui/node_modules/resolve/.claude/settings.local.json
@@ -0,0 +1,26 @@
+{
+  "permissions": {
+    "allow": [
+      "WebFetch(domain:github.com)",
+      "WebSearch",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "WebFetch(domain:api.github.com)",
+      "WebFetch(domain:www.npmjs.com)",
+      "Bash(tree:*)",
+      "Bash(find:*)",
+      "Bash(npm view:*)",
+      "Bash(node test/resolver_sync.js:*)",
+      "Bash(xxd:*)",
+      "Bash(npm info:*)",
+      "Bash(grep:*)",
+      "Bash(npm run submodule:update:*)",
+      "Bash(git rev-parse:*)",
+      "Bash(git -C test/list-exports diff packages/tests/fixtures/resolve-2/project/test/resolver/nested_symlinks/mylib/async.js)",
+      "Bash(gh run list:*)",
+      "Bash(ls:*)",
+      "Bash(tape test/homedir.js)",
+      "Bash(tape test/default_paths.js)",
+      "Bash(tape test/mock.js)"
+    ]
+  }
+}
diff --git a/tools/ui/node_modules/resolve/.editorconfig b/tools/ui/node_modules/resolve/.editorconfig
new file mode 100644
index 0000000000000000000000000000000000000000..def97c281a23082fed05f6c15ad3a2c04b139300
--- /dev/null
+++ b/tools/ui/node_modules/resolve/.editorconfig
@@ -0,0 +1,38 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 200
+
+[*.{,m}js]
+block_comment_start = /*
+block_comment = *
+block_comment_end = */
+
+[*.yml]
+indent_style = space
+indent_size = 1
+
+[{package.json,*.mjs}]
+indent_style = tab
+
+[lib/core.json]
+indent_style = tab
+
+[CHANGELOG.md]
+indent_style = space
+indent_size = 2
+
+[{*.json,Makefile,CONTRIBUTING.md}]
+max_line_length = off
+
+[test/{dotdot,resolver,module_dir,multirepo,node_path,pathfilter,precedence}/**/*]
+indent_style = off
+indent_size = off
+max_line_length = off
+insert_final_newline = off
diff --git a/tools/ui/node_modules/resolve/.eslintrc b/tools/ui/node_modules/resolve/.eslintrc
new file mode 100644
index 0000000000000000000000000000000000000000..60c73a586a6db4e6867b0daac09ce7e8631b0d33
--- /dev/null
+++ b/tools/ui/node_modules/resolve/.eslintrc
@@ -0,0 +1,65 @@
+{
+    "root": true,
+
+    "extends": "@ljharb",
+
+    "rules": {
+        "indent": [2, 4],
+        "strict": 0,
+        "complexity": 0,
+        "consistent-return": 0,
+        "curly": 0,
+        "dot-notation": [2, { "allowKeywords": true }],
+        "func-name-matching": 0,
+        "func-style": 0,
+        "global-require": 1,
+        "id-length": [2, { "min": 1, "max": 40 }],
+        "max-lines": [2, 360],
+        "max-lines-per-function": 0,
+        "max-nested-callbacks": 0,
+        "max-params": 0,
+        "max-statements-per-line": [2, { "max": 2 }],
+        "max-statements": 0,
+        "no-magic-numbers": 0,
+        "no-shadow": 0,
+        "no-use-before-define": 0,
+        "sort-keys": 0,
+    },
+    "overrides": [
+        {
+            "files": "bin/**",
+            "rules": {
+                "no-process-exit": "off",
+            },
+        },
+        {
+            "files": "example/**",
+            "rules": {
+                "no-console": 0,
+            },
+        },
+        {
+            "files": "test/resolver/nested_symlinks/mylib/*.js",
+            "rules": {
+                "no-throw-literal": 0,
+            },
+        },
+        {
+            "files": "test/**",
+            "parserOptions": {
+                "ecmaVersion": 5,
+                "allowReserved": false,
+            },
+            "rules": {
+                "dot-notation": [2, { "allowPattern": "throws" }],
+                "max-lines": 0,
+                "max-lines-per-function": 0,
+                "no-unused-vars": [2, { "vars": "all", "args": "none" }],
+            },
+        },
+    ],
+
+    "ignorePatterns": [
+        "./test/resolver/malformed_package_json/package.json",
+    ],
+}
diff --git a/tools/ui/node_modules/resolve/.github/FUNDING.yml b/tools/ui/node_modules/resolve/.github/FUNDING.yml
new file mode 100644
index 0000000000000000000000000000000000000000..d9c05955459660bd6b6a972499502b8d09958220
--- /dev/null
+++ b/tools/ui/node_modules/resolve/.github/FUNDING.yml
@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [ljharb]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: npm/resolve
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
diff --git a/tools/ui/node_modules/resolve/.github/INCIDENT_RESPONSE_PROCESS.md b/tools/ui/node_modules/resolve/.github/INCIDENT_RESPONSE_PROCESS.md
new file mode 100644
index 0000000000000000000000000000000000000000..2777753e7c781c11f0f1f8ae63884f286382b21b
--- /dev/null
+++ b/tools/ui/node_modules/resolve/.github/INCIDENT_RESPONSE_PROCESS.md
@@ -0,0 +1,119 @@
+# Incident Response Process for **resolve**
+
+## Reporting a Vulnerability
+
+We take the security of **resolve** very seriously. If you believe you’ve found a security vulnerability, please inform us responsibly through coordinated disclosure.
+
+### How to Report
+
+> **Do not** report security vulnerabilities through public GitHub issues, discussions, or social media.
+
+Instead, please use one of these secure channels:
+
+1. **GitHub Security Advisories**
+   Use the **Report a vulnerability** button in the Security tab of the [browserify/resolve repository](https://github.com/browserify/resolve).
+
+2. **Email**
+   Follow the posted [Security Policy](https://github.com/browserify/resolve/security/policy).
+
+### What to Include
+
+**Required Information:**
+- Brief description of the vulnerability type
+- Affected version(s) and components
+- Steps to reproduce the issue
+- Impact assessment (what an attacker could achieve)
+- Confirm the issue is not present in test files (in other words, only via the official entry points in `exports`)
+
+**Helpful Additional Details:**
+- Full paths of affected source files
+- Specific commit or branch where the issue exists
+- Required configuration to reproduce
+- Proof-of-concept code (if available)
+- Suggested mitigation or fix
+
+## Our Response Process
+
+**Timeline Commitments:**
+- **Initial acknowledgment**: Within 24 hours
+- **Detailed response**: Within 3 business days
+- **Status updates**: Every 7 days until resolved
+- **Resolution target**: 90 days for most issues
+
+**What We’ll Do:**
+1. Acknowledge your report and assign a tracking ID
+2. Assess the vulnerability and determine severity
+3. Develop and test a fix
+4. Coordinate disclosure timeline with you
+5. Release a security update and publish an advisory and CVE
+6. Credit you in our security advisory (if desired)
+
+## Disclosure Policy
+
+- **Coordinated disclosure**: We’ll work with you on timing
+- **Typical timeline**: 90 days from report to public disclosure
+- **Early disclosure**: If actively exploited
+- **Delayed disclosure**: For complex issues
+
+## Scope
+
+**In Scope:**
+- **resolve** package (all supported versions)
+- Official examples and documentation
+- Core resolution APIs
+- Dependencies with direct security implications
+
+**Out of Scope:**
+- Third-party wrappers or extensions
+- Bundler-specific integrations
+- Social engineering or physical attacks
+- Theoretical vulnerabilities without practical exploitation
+- Issues in non-production files
+
+## Security Measures
+
+**Our Commitments:**
+- Regular vulnerability scanning via `npm audit`
+- Automated security checks in CI/CD (GitHub Actions)
+- Secure coding practices and mandatory code review
+- Prompt patch releases for critical issues
+
+**User Responsibilities:**
+- Keep **resolve** updated
+- Monitor dependency vulnerabilities
+- Follow secure configuration guidelines for module resolution
+
+## Legal Safe Harbor
+
+**We will NOT:**
+- Initiate legal action
+- Contact law enforcement
+- Suspend or terminate your access
+
+**You must:**
+- Only test against your own installations
+- Not access, modify, or delete user data
+- Not degrade service availability
+- Not publicly disclose before coordinated disclosure
+- Act in good faith
+
+## Recognition
+
+- **Advisory Credits**: Credit in GitHub Security Advisories (unless anonymous)
+
+## Security Updates
+
+**Stay Informed:**
+- Subscribe to npm updates for **resolve**
+- Enable GitHub Security Advisory notifications
+
+**Update Process:**
+- Patch releases (e.g., 1.22.10 → 1.22.11)
+- Out-of-band releases for critical issues
+- Advisories via GitHub Security Advisories
+
+## Contact Information
+
+- **Security reports**: Security tab of [browserify/resolve](https://github.com/browserify/resolve/security)
+- **General inquiries**: GitHub Discussions or Issues
+
diff --git a/tools/ui/node_modules/resolve/.github/THREAT_MODEL.md b/tools/ui/node_modules/resolve/.github/THREAT_MODEL.md
new file mode 100644
index 0000000000000000000000000000000000000000..2952f698c8f0393b1dc9ef63ed6abe961d0fbe91
--- /dev/null
+++ b/tools/ui/node_modules/resolve/.github/THREAT_MODEL.md
@@ -0,0 +1,74 @@
+## Threat Model for resolve (module path resolution library)
+
+### 1. Library Overview
+
+- **Library Name:** resolve
+- **Brief Description:** Implements Node.js `require.resolve()` algorithm for synchronous and asynchronous file path resolution. Used to locate modules and files in Node.js projects.
+- **Key Public APIs/Functions:** `resolve.sync()` / `resolve/sync`, `resolve()` / `resolve/async`
+
+### 2. Define Scope
+
+This threat model focuses on the core path resolution algorithm, including filesystem interaction, option handling, and cache management.
+
+### 3. Conceptual System Diagram
+
+```
+Caller Application → resolve(id, options) → Resolution Algorithm → File System
+                           │
+                           └→ Options Handling
+                           └→ Cache System
+```
+
+**Trust Boundaries:**
+- **Input module IDs:** May come from untrusted sources (user input, configuration)
+- **Filesystem access:** The library interacts with the filesystem to resolve paths
+- **Options:** Provided by the caller
+- **Cache:** Used to improve performance, but could be a vector for tampering or information disclosure if not handled securely
+
+### 4. Identify Assets
+
+- **Integrity of resolution output:** Ensure correct and safe file path matching.
+- **Confidentiality of configuration:** Prevent sensitive path information from being leaked.
+- **Availability/performance for host application:** Prevent crashes or resource exhaustion.
+- **Security of host application:** Prevent path traversal or unintended filesystem access.
+- **Reputation of library:** Maintain trust by avoiding supply chain attacks and vulnerabilities[1][3][4].
+
+### 5. Identify Threats
+
+| Component / API / Interaction                       | S  | T  | R  | I  | D  | E  |
+|-----------------------------------------------------|----|----|----|----|----|----|
+| Public API Call (`resolve/async`, `resolve/sync`)   | ✓  | ✓  | –  | ✓  | –  | –  |
+| Filesystem Access                                   | –  | ✓  | –  | ✓  | ✓  | –  |
+| Options Handling                                    | ✓  | ✓  | –  | ✓  | –  | –  |
+| Cache System                                        | –  | ✓  | –  | ✓  | –  | –  |
+
+**Key Threats:**
+- **Spoofing:** Malicious module IDs mimicking legitimate packages, or spoofing configuration options[1].
+- **Tampering:** Caller-provided paths altering resolution order, or cache tampering leading to incorrect results[1][4].
+- **Information Disclosure:** Error messages revealing filesystem structure or sensitive paths[1].
+- **Denial of Service:** Recursive or excessive resolution exhausting filesystem handles or causing application crashes[1].
+- **Path Traversal:** Malicious input allowing access to files outside the intended directory[4].
+
+### 6. Mitigation/Countermeasures
+
+| Threat Identified                          | Proposed Mitigation |
+|--------------------------------------------|---------------------|
+| Spoofing (malicious module IDs/config)     | Sanitize input IDs; validate against known patterns; restrict `basedir` to app-controlled paths[1][4]. |
+| Tampering (path traversal, cache)          | Validate input IDs for directory escapes; secure cache reads/writes; restrict cache to trusted sources[1][4]. |
+| Information Disclosure (error messages)    | Generic "not found" errors without internal paths; avoid exposing sensitive configuration in errors[1]. |
+| Denial of Service (resource exhaustion)    | Limit recursive resolution depth; implement timeout; monitor for excessive filesystem operations[1]. |
+
+### 7. Risk Ranking
+
+- **High:** Path traversal via malicious IDs (if not properly mitigated)
+- **Medium:** Cache tampering or spoofing (if cache is not secured)
+- **Low:** Information disclosure in errors (if error handling is generic)
+
+### 8. Next Steps & Review
+
+1. **Implement input sanitization for module IDs and configuration.**
+2. **Add resolution depth limiting and timeout.**
+3. **Audit cache handling for race conditions and tampering.**
+4. **Regularly review dependencies for vulnerabilities.**
+5. **Keep documentation and threat model up to date.**
+6. **Monitor for new threats as the ecosystem and library evolve[1][3].**
diff --git a/tools/ui/node_modules/resolve/LICENSE b/tools/ui/node_modules/resolve/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..ff4fce28af33a4504d6960856a0bd603860a62e0
--- /dev/null
+++ b/tools/ui/node_modules/resolve/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2012 James Halliday
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/tools/ui/node_modules/resolve/SECURITY.md b/tools/ui/node_modules/resolve/SECURITY.md
new file mode 100644
index 0000000000000000000000000000000000000000..da32876e9709d6751cd3f65f300439e1348559d4
--- /dev/null
+++ b/tools/ui/node_modules/resolve/SECURITY.md
@@ -0,0 +1,13 @@
+# Security
+
+Please [file a private vulnerability report](https://github.com/browserify/resolve/security/advisories/new),
+or email [@ljharb](https://github.com/ljharb),
+if you have a potential security vulnerability to report.
+
+## Incident Response
+
+See our [Incident Response Process](.github/INCIDENT_RESPONSE_PROCESS.md).
+
+## Threat Model
+
+See [THREAT_MODEL.md](./THREAT_MODEL.md).
diff --git a/tools/ui/node_modules/resolve/async.js b/tools/ui/node_modules/resolve/async.js
new file mode 100644
index 0000000000000000000000000000000000000000..f38c5813ebd04ab8bf6988cc0186b9f95433f7e2
--- /dev/null
+++ b/tools/ui/node_modules/resolve/async.js
@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/async');
diff --git a/tools/ui/node_modules/resolve/bin/resolve b/tools/ui/node_modules/resolve/bin/resolve
new file mode 100644
index 0000000000000000000000000000000000000000..21d1a87eec1fe1557a535fc0cdfd877908cb5c71
--- /dev/null
+++ b/tools/ui/node_modules/resolve/bin/resolve
@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+
+if (
+    String(process.env.npm_lifecycle_script).slice(0, 8) !== 'resolve '
+    && (
+        !process.argv
+        || process.argv.length < 2
+        || (process.argv[1] !== __filename && fs.statSync(process.argv[1]).ino !== fs.statSync(__filename).ino)
+        || (process.env.npm_lifecycle_event !== 'npx' && process.env._ && fs.realpathSync(path.resolve(process.env._)) !== __filename)
+    )
+) {
+    console.error('Error: `resolve` must be run directly as an executable');
+    process.exit(1);
+}
+
+var supportsPreserveSymlinkFlag = require('supports-preserve-symlinks-flag');
+
+var preserveSymlinks = false;
+for (var i = 2; i < process.argv.length; i += 1) {
+    if (process.argv[i].slice(0, 2) === '--') {
+        if (supportsPreserveSymlinkFlag && process.argv[i] === '--preserve-symlinks') {
+            preserveSymlinks = true;
+        } else if (process.argv[i].length > 2) {
+            console.error('Unknown argument ' + process.argv[i].replace(/[=].*$/, ''));
+            process.exit(2);
+        }
+        process.argv.splice(i, 1);
+        i -= 1;
+        if (process.argv[i] === '--') { break; } // eslint-disable-line no-restricted-syntax
+    }
+}
+
+if (process.argv.length < 3) {
+    console.error('Error: `resolve` expects a specifier');
+    process.exit(2);
+}
+
+var resolve = require('../');
+
+var result = resolve.sync(process.argv[2], {
+    basedir: process.cwd(),
+    preserveSymlinks: preserveSymlinks
+});
+
+console.log(result);
diff --git a/tools/ui/node_modules/resolve/eslint.config.mjs b/tools/ui/node_modules/resolve/eslint.config.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..061da6f10168bfdbede5947f4b21956f13c58893
--- /dev/null
+++ b/tools/ui/node_modules/resolve/eslint.config.mjs
@@ -0,0 +1,80 @@
+import ljharb from '@ljharb/eslint-config/flat';
+
+export default [
+	...ljharb,
+	{
+		ignores: [
+			'test/resolver/malformed_package_json/package.json',
+			'test/list-exports/**',
+		],
+	},
+	{
+		rules: {
+			'array-bracket-newline': 'off',
+			complexity: 'off',
+			'consistent-return': 'off',
+			curly: 'off',
+			'dot-notation': ['error', { allowKeywords: true }],
+			'func-name-matching': 'off',
+			'func-style': 'off',
+			'global-require': 'warn',
+			'id-length': ['error', { min: 1, max: 40 }],
+			'max-depth': 'off',
+			'max-lines-per-function': 'off',
+			'max-lines': 'off',
+			'max-nested-callbacks': 'off',
+			'max-params': 'off',
+			'max-statements-per-line': ['error', { max: 2 }],
+			'max-statements': 'off',
+			'multiline-comment-style': 'off',
+			'no-magic-numbers': 'off',
+			'no-shadow': 'off',
+			'no-use-before-define': 'off',
+			'sort-keys': 'off',
+			strict: 'off',
+		},
+	},
+	{
+		files: ['**/*.js'],
+		rules: {
+			indent: ['error', 4],
+		},
+	},
+	{
+		files: ['bin/**'],
+		rules: {
+			'no-process-exit': 'off',
+		},
+	},
+	{
+		files: ['example/**'],
+		rules: {
+			'no-console': 'off',
+		},
+	},
+	{
+		files: ['test/resolver/nested_symlinks/mylib/*.js'],
+		rules: {
+			'no-throw-literal': 'off',
+		},
+	},
+	{
+		files: ['test/**'],
+		languageOptions: {
+			ecmaVersion: 5,
+			parserOptions: {
+				allowReserved: false,
+			},
+		},
+		rules: {
+			'dot-notation': ['error', { allowPattern: 'throws' }],
+			'max-lines': 'off',
+			'max-lines-per-function': 'off',
+			'no-unused-vars': ['error', {
+				vars: 'all',
+				args: 'none',
+				caughtErrors: 'none',
+			}],
+		},
+	},
+];
diff --git a/tools/ui/node_modules/resolve/example/async.js b/tools/ui/node_modules/resolve/example/async.js
new file mode 100644
index 0000000000000000000000000000000000000000..20e65dc281dbaa3947a1c5d1b1a0bc94167c2073
--- /dev/null
+++ b/tools/ui/node_modules/resolve/example/async.js
@@ -0,0 +1,5 @@
+var resolve = require('../');
+resolve('tap', { basedir: __dirname }, function (err, res) {
+    if (err) console.error(err);
+    else console.log(res);
+});
diff --git a/tools/ui/node_modules/resolve/example/sync.js b/tools/ui/node_modules/resolve/example/sync.js
new file mode 100644
index 0000000000000000000000000000000000000000..54b2cc1004223d114e38bbd46fe9a0f5b73ca7e2
--- /dev/null
+++ b/tools/ui/node_modules/resolve/example/sync.js
@@ -0,0 +1,3 @@
+var resolve = require('../');
+var res = resolve.sync('tap', { basedir: __dirname });
+console.log(res);
diff --git a/tools/ui/node_modules/resolve/index.js b/tools/ui/node_modules/resolve/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..125d8146423596fa289ec4edf8e3c78ef92eb7c7
--- /dev/null
+++ b/tools/ui/node_modules/resolve/index.js
@@ -0,0 +1,6 @@
+var async = require('./lib/async');
+async.core = require('./lib/core');
+async.isCore = require('./lib/is-core');
+async.sync = require('./lib/sync');
+
+module.exports = async;
diff --git a/tools/ui/node_modules/resolve/lib/async.js b/tools/ui/node_modules/resolve/lib/async.js
new file mode 100644
index 0000000000000000000000000000000000000000..2dfd57c2be31a4a61b4263a10cbfd03b8028ca00
--- /dev/null
+++ b/tools/ui/node_modules/resolve/lib/async.js
@@ -0,0 +1,336 @@
+var fs = require('fs');
+var getHomedir = require('./homedir');
+var path = require('path');
+var caller = require('./caller');
+var nodeModulesPaths = require('./node-modules-paths');
+var normalizeOptions = require('./normalize-options');
+var isCore = require('is-core-module');
+var $Error = require('es-errors');
+var $TypeError = require('es-errors/type');
+
+var realpathFS = process.platform !== 'win32' && fs.realpath && typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
+
+var relativePathRegex = /^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/;
+var windowsDriveRegex = /^\w:[/\\]*$/;
+var nodeModulesRegex = /[/\\]node_modules[/\\]*$/;
+
+var homedir = getHomedir();
+function defaultPaths() {
+    if (!homedir) return [];
+    return [
+        path.join(homedir, '.node_modules'),
+        path.join(homedir, '.node_libraries')
+    ];
+}
+
+var defaultIsFile = function isFile(file, cb) {
+    fs.stat(file, function (err, stat) {
+        if (!err) {
+            return cb(null, stat.isFile() || stat.isFIFO());
+        }
+        if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+        return cb(err);
+    });
+};
+
+var defaultIsDir = function isDirectory(dir, cb) {
+    fs.stat(dir, function (err, stat) {
+        if (!err) {
+            return cb(null, stat.isDirectory());
+        }
+        if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+        return cb(err);
+    });
+};
+
+var defaultRealpath = function realpath(x, cb) {
+    realpathFS(x, function (realpathErr, realPath) {
+        if (realpathErr && realpathErr.code !== 'ENOENT') cb(realpathErr);
+        else cb(null, realpathErr ? x : realPath);
+    });
+};
+
+function maybeRealpath(realpath, x, opts, cb) {
+    if (opts && opts.preserveSymlinks === false) {
+        realpath(x, cb);
+    } else {
+        cb(null, x);
+    }
+}
+
+function defaultReadPackage(readFile, pkgfile, cb) {
+    readFile(pkgfile, function (readFileErr, body) {
+        if (readFileErr) cb(readFileErr);
+        else {
+            try {
+                var pkg = JSON.parse(body);
+                cb(null, pkg);
+            } catch (jsonErr) {
+                cb(null);
+            }
+        }
+    });
+}
+
+function getPackageCandidates(x, start, opts) {
+    var dirs = nodeModulesPaths(start, opts, x);
+    for (var i = 0; i < dirs.length; i++) {
+        dirs[i] = path.join(dirs[i], x);
+    }
+    return dirs;
+}
+
+module.exports = function resolve(x, options, callback) {
+    var cb = callback;
+    var opts = options;
+    if (typeof options === 'function') {
+        cb = opts;
+        opts = {};
+    }
+    if (typeof x !== 'string') {
+        var err = new $TypeError('Path must be a string.');
+        return process.nextTick(function () {
+            cb(err);
+        });
+    }
+
+    opts = normalizeOptions(x, opts);
+
+    var isFile = opts.isFile || defaultIsFile;
+    var isDirectory = opts.isDirectory || defaultIsDir;
+    var readFile = opts.readFile || fs.readFile;
+    var realpath = opts.realpath || defaultRealpath;
+    var readPackage = opts.readPackage || defaultReadPackage;
+    if (opts.readFile && opts.readPackage) {
+        var conflictErr = new $TypeError('`readFile` and `readPackage` are mutually exclusive.');
+        return process.nextTick(function () {
+            cb(conflictErr);
+        });
+    }
+    var packageIterator = opts.packageIterator;
+
+    var extensions = opts.extensions || ['.js'];
+    var includeCoreModules = opts.includeCoreModules !== false;
+    var basedir = opts.basedir || path.dirname(caller());
+    var parent = opts.filename || basedir;
+
+    opts.paths = opts.paths || defaultPaths();
+
+    // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+    var absoluteStart = path.resolve(basedir);
+
+    maybeRealpath(
+        realpath,
+        absoluteStart,
+        opts,
+        function (err, realStart) {
+            if (err) cb(err);
+            else init(realStart);
+        }
+    );
+
+    var res;
+    function init(basedir) {
+        if (relativePathRegex.test(x)) {
+            res = path.resolve(basedir, x);
+            if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+            if (x.slice(-1) === '/' && res === basedir) {
+                loadAsDirectory(res, opts.package, onfile);
+            } else loadAsFile(res, opts.package, onfile);
+        } else if (includeCoreModules && isCore(x)) {
+            return cb(null, x);
+        } else loadNodeModules(x, basedir, function (err, n, pkg) {
+            if (err) cb(err);
+            else if (n) {
+                return maybeRealpath(realpath, n, opts, function (err, realN) {
+                    if (err) {
+                        cb(err);
+                    } else {
+                        cb(null, realN, pkg);
+                    }
+                });
+            } else {
+                var moduleError = new $Error("Cannot find module '" + x + "' from '" + parent + "'");
+                moduleError.code = 'MODULE_NOT_FOUND';
+                cb(moduleError);
+            }
+        });
+    }
+
+    function onfile(err, m, pkg) {
+        if (err) cb(err);
+        else if (m) cb(null, m, pkg);
+        else loadAsDirectory(res, function (err, d, pkg) {
+            if (err) cb(err);
+            else if (d) {
+                maybeRealpath(realpath, d, opts, function (err, realD) {
+                    if (err) {
+                        cb(err);
+                    } else {
+                        cb(null, realD, pkg);
+                    }
+                });
+            } else {
+                var moduleError = new $Error("Cannot find module '" + x + "' from '" + parent + "'");
+                moduleError.code = 'MODULE_NOT_FOUND';
+                cb(moduleError);
+            }
+        });
+    }
+
+    function loadAsFile(x, thePackage, callback) {
+        var loadAsFilePackage = thePackage;
+        var cb = callback;
+        if (typeof loadAsFilePackage === 'function') {
+            cb = loadAsFilePackage;
+            loadAsFilePackage = undefined;
+        }
+
+        var exts = [''].concat(extensions);
+        load(exts, x, loadAsFilePackage);
+
+        function load(exts, x, loadPackage) {
+            if (exts.length === 0) return cb(null, undefined, loadPackage);
+            var file = x + exts[0];
+
+            var pkg = loadPackage;
+            if (pkg) onpkg(null, pkg);
+            else loadpkg(path.dirname(file), onpkg);
+
+            function onpkg(err, pkg_, dir) {
+                pkg = pkg_;
+                if (err) return cb(err);
+                if (dir && pkg && opts.pathFilter) {
+                    var rfile = path.relative(dir, file);
+                    var rel = rfile.slice(0, rfile.length - exts[0].length);
+                    var r = opts.pathFilter(pkg, x, rel);
+                    if (r) return load(
+                        [''].concat(extensions),
+                        path.resolve(dir, r),
+                        pkg
+                    );
+                }
+                isFile(file, onex);
+            }
+            function onex(err, ex) {
+                if (err) return cb(err);
+                if (ex) return cb(null, file, pkg);
+                load(exts.slice(1), x, pkg);
+            }
+        }
+    }
+
+    function loadpkg(dir, cb) {
+        if (dir === '' || dir === '/') return cb(null);
+        if (process.platform === 'win32' && windowsDriveRegex.test(dir)) {
+            return cb(null);
+        }
+        if (nodeModulesRegex.test(dir)) return cb(null);
+
+        maybeRealpath(realpath, dir, opts, function (unwrapErr, pkgdir) {
+            if (unwrapErr) return loadpkg(path.dirname(dir), cb);
+            var pkgfile = path.join(pkgdir, 'package.json');
+            isFile(pkgfile, function (err, ex) {
+                // on err, ex is false
+                if (!ex) return loadpkg(path.dirname(dir), cb);
+
+                readPackage(readFile, pkgfile, function (err, pkgParam) {
+                    if (err) { return cb(err); }
+
+                    var pkg = pkgParam;
+
+                    if (pkg && opts.packageFilter) {
+                        pkg = opts.packageFilter(pkg, pkgfile);
+                    }
+                    cb(null, pkg, dir);
+                });
+            });
+        });
+    }
+
+    function loadAsDirectory(x, loadAsDirectoryPackage, callback) {
+        var cb = callback;
+        var fpkg = loadAsDirectoryPackage;
+        if (typeof fpkg === 'function') {
+            cb = fpkg;
+            fpkg = opts.package;
+        }
+
+        maybeRealpath(realpath, x, opts, function (unwrapErr, pkgdir) {
+            if (unwrapErr) return cb(unwrapErr);
+            var pkgfile = path.join(pkgdir, 'package.json');
+            isFile(pkgfile, function (err, ex) {
+                if (err) return cb(err);
+                if (!ex) return loadAsFile(path.join(x, 'index'), fpkg, cb);
+
+                readPackage(readFile, pkgfile, function (err, pkgParam) {
+                    if (err) return cb(err);
+
+                    var pkg = pkgParam;
+
+                    if (pkg && opts.packageFilter) {
+                        pkg = opts.packageFilter(pkg, pkgfile);
+                    }
+
+                    if (pkg && pkg.main) {
+                        if (typeof pkg.main !== 'string') {
+                            var mainError = new $TypeError('package “' + pkg.name + '” `main` must be a string');
+                            mainError.code = 'INVALID_PACKAGE_MAIN';
+                            return cb(mainError);
+                        }
+                        if (pkg.main === '.' || pkg.main === './') {
+                            pkg.main = 'index';
+                        }
+                        loadAsFile(path.resolve(x, pkg.main), pkg, function (err, m, pkg) {
+                            if (err) return cb(err);
+                            if (m) return cb(null, m, pkg);
+                            if (!pkg) return loadAsFile(path.join(x, 'index'), pkg, cb);
+
+                            var dir = path.resolve(x, pkg.main);
+                            loadAsDirectory(dir, pkg, function (err, n, pkg) {
+                                if (err) return cb(err);
+                                if (n) return cb(null, n, pkg);
+                                loadAsFile(path.join(x, 'index'), pkg, cb);
+                            });
+                        });
+                        return;
+                    }
+
+                    loadAsFile(path.join(x, '/index'), pkg, cb);
+                });
+            });
+        });
+    }
+
+    function processDirs(cb, dirs) {
+        if (dirs.length === 0) return cb(null, undefined);
+        var dir = dirs[0];
+
+        isDirectory(path.dirname(dir), isdir);
+
+        function isdir(err, isdir) {
+            if (err) return cb(err);
+            if (!isdir) return processDirs(cb, dirs.slice(1));
+            loadAsFile(dir, opts.package, onfile);
+        }
+
+        function onfile(err, m, pkg) {
+            if (err) return cb(err);
+            if (m) return cb(null, m, pkg);
+            loadAsDirectory(dir, opts.package, ondir);
+        }
+
+        function ondir(err, n, pkg) {
+            if (err) return cb(err);
+            if (n) return cb(null, n, pkg);
+            processDirs(cb, dirs.slice(1));
+        }
+    }
+    function loadNodeModules(x, start, cb) {
+        var thunk = function () { return getPackageCandidates(x, start, opts); };
+        processDirs(
+            cb,
+            packageIterator ? packageIterator(x, start, thunk, opts) : thunk()
+        );
+    }
+};
diff --git a/tools/ui/node_modules/resolve/lib/caller.js b/tools/ui/node_modules/resolve/lib/caller.js
new file mode 100644
index 0000000000000000000000000000000000000000..72fd8e37e52dbf0250f4b12be029c1cc8e772a01
--- /dev/null
+++ b/tools/ui/node_modules/resolve/lib/caller.js
@@ -0,0 +1,12 @@
+'use strict';
+
+var $Error = require('es-errors');
+
+module.exports = function () {
+    // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
+    var origPrepareStackTrace = $Error.prepareStackTrace;
+    $Error.prepareStackTrace = function (_, stack) { return stack; };
+    var stack = (new $Error()).stack;
+    $Error.prepareStackTrace = origPrepareStackTrace;
+    return stack[2].getFileName();
+};
diff --git a/tools/ui/node_modules/resolve/lib/core.js b/tools/ui/node_modules/resolve/lib/core.js
new file mode 100644
index 0000000000000000000000000000000000000000..57b048f1386ff93b941e8d375d878041535f1964
--- /dev/null
+++ b/tools/ui/node_modules/resolve/lib/core.js
@@ -0,0 +1,12 @@
+'use strict';
+
+var isCoreModule = require('is-core-module');
+var data = require('./core.json');
+
+var core = {};
+for (var mod in data) { // eslint-disable-line no-restricted-syntax
+    if (Object.prototype.hasOwnProperty.call(data, mod)) {
+        core[mod] = isCoreModule(mod);
+    }
+}
+module.exports = core;
diff --git a/tools/ui/node_modules/resolve/lib/core.json b/tools/ui/node_modules/resolve/lib/core.json
new file mode 100644
index 0000000000000000000000000000000000000000..930ec682569d00580746bfb86cd18a2c7225cb8b
--- /dev/null
+++ b/tools/ui/node_modules/resolve/lib/core.json
@@ -0,0 +1,162 @@
+{
+	"assert": true,
+	"node:assert": [">= 14.18 && < 15", ">= 16"],
+	"assert/strict": ">= 15",
+	"node:assert/strict": ">= 16",
+	"async_hooks": ">= 8",
+	"node:async_hooks": [">= 14.18 && < 15", ">= 16"],
+	"buffer_ieee754": ">= 0.5 && < 0.9.7",
+	"buffer": true,
+	"node:buffer": [">= 14.18 && < 15", ">= 16"],
+	"child_process": true,
+	"node:child_process": [">= 14.18 && < 15", ">= 16"],
+	"cluster": ">= 0.5",
+	"node:cluster": [">= 14.18 && < 15", ">= 16"],
+	"console": true,
+	"node:console": [">= 14.18 && < 15", ">= 16"],
+	"constants": true,
+	"node:constants": [">= 14.18 && < 15", ">= 16"],
+	"crypto": true,
+	"node:crypto": [">= 14.18 && < 15", ">= 16"],
+	"_debug_agent": ">= 1 && < 8",
+	"_debugger": "< 8",
+	"dgram": true,
+	"node:dgram": [">= 14.18 && < 15", ">= 16"],
+	"diagnostics_channel": [">= 14.17 && < 15", ">= 15.1"],
+	"node:diagnostics_channel": [">= 14.18 && < 15", ">= 16"],
+	"dns": true,
+	"node:dns": [">= 14.18 && < 15", ">= 16"],
+	"dns/promises": ">= 15",
+	"node:dns/promises": ">= 16",
+	"domain": ">= 0.7.12",
+	"node:domain": [">= 14.18 && < 15", ">= 16"],
+	"events": true,
+	"node:events": [">= 14.18 && < 15", ">= 16"],
+	"freelist": "< 6",
+	"fs": true,
+	"node:fs": [">= 14.18 && < 15", ">= 16"],
+	"fs/promises": [">= 10 && < 10.1", ">= 14"],
+	"node:fs/promises": [">= 14.18 && < 15", ">= 16"],
+	"_http_agent": ">= 0.11.1",
+	"node:_http_agent": [">= 14.18 && < 15", ">= 16"],
+	"_http_client": ">= 0.11.1",
+	"node:_http_client": [">= 14.18 && < 15", ">= 16"],
+	"_http_common": ">= 0.11.1",
+	"node:_http_common": [">= 14.18 && < 15", ">= 16"],
+	"_http_incoming": ">= 0.11.1",
+	"node:_http_incoming": [">= 14.18 && < 15", ">= 16"],
+	"_http_outgoing": ">= 0.11.1",
+	"node:_http_outgoing": [">= 14.18 && < 15", ">= 16"],
+	"_http_server": ">= 0.11.1",
+	"node:_http_server": [">= 14.18 && < 15", ">= 16"],
+	"http": true,
+	"node:http": [">= 14.18 && < 15", ">= 16"],
+	"http2": ">= 8.8",
+	"node:http2": [">= 14.18 && < 15", ">= 16"],
+	"https": true,
+	"node:https": [">= 14.18 && < 15", ">= 16"],
+	"inspector": ">= 8",
+	"node:inspector": [">= 14.18 && < 15", ">= 16"],
+	"inspector/promises": [">= 19"],
+	"node:inspector/promises": [">= 19"],
+	"_linklist": "< 8",
+	"module": true,
+	"node:module": [">= 14.18 && < 15", ">= 16"],
+	"net": true,
+	"node:net": [">= 14.18 && < 15", ">= 16"],
+	"node-inspect/lib/_inspect": ">= 7.6 && < 12",
+	"node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
+	"node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
+	"os": true,
+	"node:os": [">= 14.18 && < 15", ">= 16"],
+	"path": true,
+	"node:path": [">= 14.18 && < 15", ">= 16"],
+	"path/posix": ">= 15.3",
+	"node:path/posix": ">= 16",
+	"path/win32": ">= 15.3",
+	"node:path/win32": ">= 16",
+	"perf_hooks": ">= 8.5",
+	"node:perf_hooks": [">= 14.18 && < 15", ">= 16"],
+	"process": ">= 1",
+	"node:process": [">= 14.18 && < 15", ">= 16"],
+	"punycode": ">= 0.5",
+	"node:punycode": [">= 14.18 && < 15", ">= 16"],
+	"querystring": true,
+	"node:querystring": [">= 14.18 && < 15", ">= 16"],
+	"readline": true,
+	"node:readline": [">= 14.18 && < 15", ">= 16"],
+	"readline/promises": ">= 17",
+	"node:readline/promises": ">= 17",
+	"repl": true,
+	"node:repl": [">= 14.18 && < 15", ">= 16"],
+	"node:sea": [">= 20.12 && < 21", ">= 21.7"],
+	"smalloc": ">= 0.11.5 && < 3",
+	"node:sqlite": [">= 22.13 && < 23", ">= 23.4"],
+	"_stream_duplex": ">= 0.9.4",
+	"node:_stream_duplex": [">= 14.18 && < 15", ">= 16"],
+	"_stream_transform": ">= 0.9.4",
+	"node:_stream_transform": [">= 14.18 && < 15", ">= 16"],
+	"_stream_wrap": ">= 1.4.1",
+	"node:_stream_wrap": [">= 14.18 && < 15", ">= 16"],
+	"_stream_passthrough": ">= 0.9.4",
+	"node:_stream_passthrough": [">= 14.18 && < 15", ">= 16"],
+	"_stream_readable": ">= 0.9.4",
+	"node:_stream_readable": [">= 14.18 && < 15", ">= 16"],
+	"_stream_writable": ">= 0.9.4",
+	"node:_stream_writable": [">= 14.18 && < 15", ">= 16"],
+	"stream": true,
+	"node:stream": [">= 14.18 && < 15", ">= 16"],
+	"stream/consumers": ">= 16.7",
+	"node:stream/consumers": ">= 16.7",
+	"stream/promises": ">= 15",
+	"node:stream/promises": ">= 16",
+	"stream/web": ">= 16.5",
+	"node:stream/web": ">= 16.5",
+	"string_decoder": true,
+	"node:string_decoder": [">= 14.18 && < 15", ">= 16"],
+	"sys": [">= 0.4 && < 0.7", ">= 0.8"],
+	"node:sys": [">= 14.18 && < 15", ">= 16"],
+	"test/reporters": ">= 19.9 && < 20.2",
+	"node:test/reporters": [">= 18.17 && < 19", ">= 19.9", ">= 20"],
+	"test/mock_loader": ">= 22.3 && < 22.7",
+	"node:test/mock_loader": ">= 22.3 && < 22.7",
+	"node:test": [">= 16.17 && < 17", ">= 18"],
+	"timers": true,
+	"node:timers": [">= 14.18 && < 15", ">= 16"],
+	"timers/promises": ">= 15",
+	"node:timers/promises": ">= 16",
+	"_tls_common": ">= 0.11.13",
+	"node:_tls_common": [">= 14.18 && < 15", ">= 16"],
+	"_tls_legacy": ">= 0.11.3 && < 10",
+	"_tls_wrap": ">= 0.11.3",
+	"node:_tls_wrap": [">= 14.18 && < 15", ">= 16"],
+	"tls": true,
+	"node:tls": [">= 14.18 && < 15", ">= 16"],
+	"trace_events": ">= 10",
+	"node:trace_events": [">= 14.18 && < 15", ">= 16"],
+	"tty": true,
+	"node:tty": [">= 14.18 && < 15", ">= 16"],
+	"url": true,
+	"node:url": [">= 14.18 && < 15", ">= 16"],
+	"util": true,
+	"node:util": [">= 14.18 && < 15", ">= 16"],
+	"util/types": ">= 15.3",
+	"node:util/types": ">= 16",
+	"v8/tools/arguments": ">= 10 && < 12",
+	"v8/tools/codemap": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+	"v8/tools/consarray": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+	"v8/tools/csvparser": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+	"v8/tools/logreader": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+	"v8/tools/profile_view": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+	"v8/tools/splaytree": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+	"v8": ">= 1",
+	"node:v8": [">= 14.18 && < 15", ">= 16"],
+	"vm": true,
+	"node:vm": [">= 14.18 && < 15", ">= 16"],
+	"wasi": [">= 13.4 && < 13.5", ">= 18.17 && < 19", ">= 20"],
+	"node:wasi": [">= 18.17 && < 19", ">= 20"],
+	"worker_threads": ">= 11.7",
+	"node:worker_threads": [">= 14.18 && < 15", ">= 16"],
+	"zlib": ">= 0.5",
+	"node:zlib": [">= 14.18 && < 15", ">= 16"]
+}
diff --git a/tools/ui/node_modules/resolve/lib/homedir.js b/tools/ui/node_modules/resolve/lib/homedir.js
new file mode 100644
index 0000000000000000000000000000000000000000..42726f9a9df117ae571f158ccc1aed48ba71234c
--- /dev/null
+++ b/tools/ui/node_modules/resolve/lib/homedir.js
@@ -0,0 +1,31 @@
+'use strict';
+
+var os = require('os');
+
+// adapted from https://github.com/sindresorhus/os-homedir/blob/11e089f4754db38bb535e5a8416320c4446e8cfd/index.js
+
+module.exports = os.homedir || function homedir() {
+    var home = process.env.HOME;
+    var user = process.env.LOGNAME || process.env.USER || process.env.LNAME || process.env.USERNAME;
+
+    if (process.platform === 'win32') {
+        return process.env.USERPROFILE
+            || (
+                process.env.HOMEDRIVE
+                && process.env.HOMEPATH
+                && (process.env.HOMEDRIVE + process.env.HOMEPATH)
+            )
+            || home
+            || null;
+    }
+
+    if (process.platform === 'darwin') {
+        return home || (user ? '/Users/' + user : null);
+    }
+
+    if (process.platform === 'linux') {
+        return home || (process.getuid() === 0 ? '/root' : (user ? '/home/' + user : null)); // eslint-disable-line no-extra-parens
+    }
+
+    return home || null;
+};
diff --git a/tools/ui/node_modules/resolve/lib/is-core.js b/tools/ui/node_modules/resolve/lib/is-core.js
new file mode 100644
index 0000000000000000000000000000000000000000..537f5c782ffe55c97e43920e8405856a9e828ada
--- /dev/null
+++ b/tools/ui/node_modules/resolve/lib/is-core.js
@@ -0,0 +1,5 @@
+var isCoreModule = require('is-core-module');
+
+module.exports = function isCore(x) {
+    return isCoreModule(x);
+};
diff --git a/tools/ui/node_modules/resolve/lib/node-modules-paths.js b/tools/ui/node_modules/resolve/lib/node-modules-paths.js
new file mode 100644
index 0000000000000000000000000000000000000000..c92f409ec117fd7bff02b37b931eff25cf25b8de
--- /dev/null
+++ b/tools/ui/node_modules/resolve/lib/node-modules-paths.js
@@ -0,0 +1,45 @@
+var path = require('path');
+var parse = path.parse || require('path-parse'); // eslint-disable-line global-require
+
+var driveLetterRegex = /^([A-Za-z]:)/;
+var uncPathRegex = /^\\\\/;
+
+function getNodeModulesDirs(absoluteStart, modules) {
+    var prefix = '/';
+    if (driveLetterRegex.test(absoluteStart)) {
+        prefix = '';
+    } else if (uncPathRegex.test(absoluteStart)) {
+        prefix = '\\\\';
+    }
+
+    var paths = [absoluteStart];
+    var parsed = parse(absoluteStart);
+    while (parsed.dir !== paths[paths.length - 1]) {
+        paths.push(parsed.dir);
+        parsed = parse(parsed.dir);
+    }
+
+    return paths.reduce(function (dirs, aPath) {
+        return dirs.concat(modules.map(function (moduleDir) {
+            return path.resolve(prefix, aPath, moduleDir);
+        }));
+    }, []);
+}
+
+module.exports = function nodeModulesPaths(start, opts, request) {
+    var modules = opts && opts.moduleDirectory
+        ? [].concat(opts.moduleDirectory)
+        : ['node_modules'];
+
+    if (opts && typeof opts.paths === 'function') {
+        return opts.paths(
+            request,
+            start,
+            function () { return getNodeModulesDirs(start, modules); },
+            opts
+        );
+    }
+
+    var dirs = getNodeModulesDirs(start, modules);
+    return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
+};
diff --git a/tools/ui/node_modules/resolve/lib/normalize-options.js b/tools/ui/node_modules/resolve/lib/normalize-options.js
new file mode 100644
index 0000000000000000000000000000000000000000..4b56904eaea72ba024f96728fff40e1be4af7df0
--- /dev/null
+++ b/tools/ui/node_modules/resolve/lib/normalize-options.js
@@ -0,0 +1,10 @@
+module.exports = function (x, opts) {
+    /**
+     * This file is purposefully a passthrough. It's expected that third-party
+     * environments will override it at runtime in order to inject special logic
+     * into `resolve` (by manipulating the options). One such example is the PnP
+     * code path in Yarn.
+     */
+
+    return opts || {};
+};
diff --git a/tools/ui/node_modules/resolve/lib/sync.js b/tools/ui/node_modules/resolve/lib/sync.js
new file mode 100644
index 0000000000000000000000000000000000000000..f785bb9b33c20565832e0609127fd83ac0dfd0fd
--- /dev/null
+++ b/tools/ui/node_modules/resolve/lib/sync.js
@@ -0,0 +1,216 @@
+var isCore = require('is-core-module');
+var fs = require('fs');
+var path = require('path');
+var $Error = require('es-errors');
+var $TypeError = require('es-errors/type');
+
+var getHomedir = require('./homedir');
+var caller = require('./caller');
+var nodeModulesPaths = require('./node-modules-paths');
+var normalizeOptions = require('./normalize-options');
+
+var realpathFS = process.platform !== 'win32' && fs.realpathSync && typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
+
+var relativePathRegex = /^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/;
+var windowsDriveRegex = /^\w:[/\\]*$/;
+var nodeModulesRegex = /[/\\]node_modules[/\\]*$/;
+
+var homedir = getHomedir();
+function defaultPaths() {
+    if (!homedir) return [];
+    return [
+        path.join(homedir, '.node_modules'),
+        path.join(homedir, '.node_libraries')
+    ];
+}
+
+var defaultIsFile = function isFile(file) {
+    try {
+        var stat = fs.statSync(file, { throwIfNoEntry: false });
+    } catch (e) {
+        if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+        throw e;
+    }
+    return !!stat && (stat.isFile() || stat.isFIFO());
+};
+
+var defaultIsDir = function isDirectory(dir) {
+    try {
+        var stat = fs.statSync(dir, { throwIfNoEntry: false });
+    } catch (e) {
+        if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+        throw e;
+    }
+    return !!stat && stat.isDirectory();
+};
+
+var defaultRealpathSync = function realpathSync(x) {
+    try {
+        return realpathFS(x);
+    } catch (realpathErr) {
+        if (realpathErr.code !== 'ENOENT') {
+            throw realpathErr;
+        }
+    }
+    return x;
+};
+
+function maybeRealpathSync(realpathSync, x, opts) {
+    if (opts && opts.preserveSymlinks === false) {
+        return realpathSync(x);
+    }
+    return x;
+}
+
+function defaultReadPackageSync(readFileSync, pkgfile) {
+    var body = readFileSync(pkgfile);
+    try {
+        var pkg = JSON.parse(body);
+        return pkg;
+    } catch (jsonErr) {}
+}
+
+function getPackageCandidates(x, start, opts) {
+    var dirs = nodeModulesPaths(start, opts, x);
+    for (var i = 0; i < dirs.length; i++) {
+        dirs[i] = path.join(dirs[i], x);
+    }
+    return dirs;
+}
+
+module.exports = function resolveSync(x, options) {
+    if (typeof x !== 'string') {
+        throw new $TypeError('Path must be a string.');
+    }
+    var opts = normalizeOptions(x, options);
+
+    var isFile = opts.isFile || defaultIsFile;
+    var readFileSync = opts.readFileSync || fs.readFileSync;
+    var isDirectory = opts.isDirectory || defaultIsDir;
+    var realpathSync = opts.realpathSync || defaultRealpathSync;
+    var readPackageSync = opts.readPackageSync || defaultReadPackageSync;
+    if (opts.readFileSync && opts.readPackageSync) {
+        throw new $TypeError('`readFileSync` and `readPackageSync` are mutually exclusive.');
+    }
+    var packageIterator = opts.packageIterator;
+
+    var extensions = opts.extensions || ['.js'];
+    var includeCoreModules = opts.includeCoreModules !== false;
+    var basedir = opts.basedir || path.dirname(caller());
+    var parent = opts.filename || basedir;
+
+    opts.paths = opts.paths || defaultPaths();
+
+    // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+    var absoluteStart = maybeRealpathSync(realpathSync, path.resolve(basedir), opts);
+
+    if (relativePathRegex.test(x)) {
+        var res = path.resolve(absoluteStart, x);
+        if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+        var m = loadAsFileSync(res) || loadAsDirectorySync(res);
+        if (m) return maybeRealpathSync(realpathSync, m, opts);
+    } else if (includeCoreModules && isCore(x)) {
+        return x;
+    } else {
+        var n = loadNodeModulesSync(x, absoluteStart);
+        if (n) return maybeRealpathSync(realpathSync, n, opts);
+    }
+
+    var err = new $Error("Cannot find module '" + x + "' from '" + parent + "'");
+    err.code = 'MODULE_NOT_FOUND';
+    throw err;
+
+    function loadAsFileSync(x) {
+        var pkg = loadpkg(path.dirname(x));
+
+        if (pkg && pkg.dir && pkg.pkg && opts.pathFilter) {
+            var rfile = path.relative(pkg.dir, x);
+            var r = opts.pathFilter(pkg.pkg, x, rfile);
+            if (r) {
+                x = path.resolve(pkg.dir, r); // eslint-disable-line no-param-reassign
+            }
+        }
+
+        if (isFile(x)) {
+            return x;
+        }
+
+        for (var i = 0; i < extensions.length; i++) {
+            var file = x + extensions[i];
+            if (isFile(file)) {
+                return file;
+            }
+        }
+    }
+
+    function loadpkg(dir) {
+        if (dir === '' || dir === '/') return;
+        if (process.platform === 'win32' && windowsDriveRegex.test(dir)) {
+            return;
+        }
+        if (nodeModulesRegex.test(dir)) return;
+
+        var pkgfile = path.join(maybeRealpathSync(realpathSync, dir, opts), 'package.json');
+
+        if (!isFile(pkgfile)) {
+            return loadpkg(path.dirname(dir));
+        }
+
+        var pkg = readPackageSync(readFileSync, pkgfile);
+
+        if (pkg && opts.packageFilter) {
+            // v2 will pass pkgfile
+            pkg = opts.packageFilter(pkg, /*pkgfile,*/ dir); // eslint-disable-line spaced-comment
+        }
+
+        return { pkg: pkg, dir: dir };
+    }
+
+    function loadAsDirectorySync(x) {
+        var pkgfile = path.join(maybeRealpathSync(realpathSync, x, opts), '/package.json');
+        if (isFile(pkgfile)) {
+            try {
+                var pkg = readPackageSync(readFileSync, pkgfile);
+            } catch (e) {}
+
+            if (pkg && opts.packageFilter) {
+                // v2 will pass pkgfile
+                pkg = opts.packageFilter(pkg, /*pkgfile,*/ x); // eslint-disable-line spaced-comment
+            }
+
+            if (pkg && pkg.main) {
+                if (typeof pkg.main !== 'string') {
+                    var mainError = new $TypeError('package “' + pkg.name + '” `main` must be a string');
+                    mainError.code = 'INVALID_PACKAGE_MAIN';
+                    throw mainError;
+                }
+                if (pkg.main === '.' || pkg.main === './') {
+                    pkg.main = 'index';
+                }
+                try {
+                    var m = loadAsFileSync(path.resolve(x, pkg.main));
+                    if (m) return m;
+                    var n = loadAsDirectorySync(path.resolve(x, pkg.main));
+                    if (n) return n;
+                } catch (e) {}
+            }
+        }
+
+        return loadAsFileSync(path.join(x, '/index'));
+    }
+
+    function loadNodeModulesSync(x, start) {
+        var thunk = function () { return getPackageCandidates(x, start, opts); };
+        var dirs = packageIterator ? packageIterator(x, start, thunk, opts) : thunk();
+
+        for (var i = 0; i < dirs.length; i++) {
+            var dir = dirs[i];
+            if (isDirectory(path.dirname(dir))) {
+                var m = loadAsFileSync(dir);
+                if (m) return m;
+                var n = loadAsDirectorySync(dir);
+                if (n) return n;
+            }
+        }
+    }
+};
diff --git a/tools/ui/node_modules/resolve/package.json b/tools/ui/node_modules/resolve/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..fbaf8ead3709458bfb4d0de6f247cf1f0454a2b6
--- /dev/null
+++ b/tools/ui/node_modules/resolve/package.json
@@ -0,0 +1,78 @@
+{
+	"name": "resolve",
+	"description": "resolve like require.resolve() on behalf of files asynchronously and synchronously",
+	"version": "1.22.12",
+	"repository": {
+		"type": "git",
+		"url": "ssh://github.com/browserify/resolve.git"
+	},
+	"bin": {
+		"resolve": "./bin/resolve"
+	},
+	"main": "index.js",
+	"keywords": [
+		"resolve",
+		"require",
+		"node",
+		"module"
+	],
+	"scripts": {
+		"prepack": "npmignore --auto --commentLines=autogenerated && cp node_modules/is-core-module/core.json ./lib/ ||:",
+		"prepublishOnly": "safe-publish-latest",
+		"prepublish": "not-in-publish || npm run prepublishOnly",
+		"prelint": "eclint check $(git ls-files | grep -Ev test\\/list-exports$ | xargs find 2> /dev/null | grep -vE 'node_modules|\\.git')",
+		"lint": "eslint .",
+		"pretests-only": "cd ./test/resolver/nested_symlinks && node mylib/sync && node mylib/async",
+		"tests-only": "tape test/*.js",
+		"pretest": "npm run lint",
+		"test": "npm run --silent tests-only",
+		"posttest": "npm run test:multirepo && npx npm@'>= 10.2' audit --production",
+		"test:multirepo": "cd ./test/resolver/multirepo && npm install && npm test"
+	},
+	"devDependencies": {
+		"@ljharb/eslint-config": "^22.2.2",
+		"array.prototype.map": "^1.0.8",
+		"copy-dir": "^1.3.0",
+		"eclint": "^2.8.1",
+		"eslint": "^9.39.1",
+		"in-publish": "^2.0.1",
+		"jiti": "^0.0.0",
+		"mkdirp": "^0.5.6",
+		"mv": "^2.1.1",
+		"npmignore": "^0.3.5",
+		"object-keys": "^1.1.1",
+		"rimraf": "^2.7.1",
+		"safe-publish-latest": "^2.0.0",
+		"semver": "^6.3.1",
+		"tap": "^0.4.13",
+		"tape": "^5.9.0",
+		"tmp": "^0.0.31"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "James Halliday",
+		"email": "mail@substack.net",
+		"url": "http://substack.net"
+	},
+	"funding": {
+		"url": "https://github.com/sponsors/ljharb"
+	},
+	"dependencies": {
+		"es-errors": "^1.3.0",
+		"is-core-module": "^2.16.1",
+		"path-parse": "^1.0.7",
+		"supports-preserve-symlinks-flag": "^1.0.0"
+	},
+	"publishConfig": {
+		"ignore": [
+			".github/workflows",
+			"appveyor.yml",
+			"CONTRIBUTING.md",
+			"test/resolver/malformed_package_json",
+			"test/list-exports"
+		]
+	},
+	"engines": {
+		"node": ">= 0.4"
+	}
+}
diff --git a/tools/ui/node_modules/resolve/readme.markdown b/tools/ui/node_modules/resolve/readme.markdown
new file mode 100644
index 0000000000000000000000000000000000000000..a255a6466d8a31c408a11a5e1a31466d8c6ff22d
--- /dev/null
+++ b/tools/ui/node_modules/resolve/readme.markdown
@@ -0,0 +1,300 @@
+# resolve [![Version Badge][2]][1]
+
+implements the [node `require.resolve()` algorithm](https://nodejs.org/api/modules.html#modules_all_together) such that you can `require.resolve()` on behalf of a file asynchronously and synchronously
+
+[![github actions][actions-image]][actions-url]
+[![coverage][codecov-image]][codecov-url]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/10759/badge)](https://bestpractices.coreinfrastructure.org/projects/10759)
+
+[![npm badge][11]][1]
+
+# example
+
+asynchronously resolve:
+
+```js
+var resolve = require('resolve/async'); // or, require('resolve')
+resolve('tap', { basedir: __dirname }, function (err, res) {
+    if (err) console.error(err);
+    else console.log(res);
+});
+```
+
+```
+$ node example/async.js
+/home/substack/projects/node-resolve/node_modules/tap/lib/main.js
+```
+
+synchronously resolve:
+
+```js
+var resolve = require('resolve/sync'); // or, `require('resolve').sync
+var res = resolve('tap', { basedir: __dirname });
+console.log(res);
+```
+
+```
+$ node example/sync.js
+/home/substack/projects/node-resolve/node_modules/tap/lib/main.js
+```
+
+# methods
+
+```js
+var resolve = require('resolve');
+var async = require('resolve/async');
+var sync = require('resolve/sync');
+```
+
+For both the synchronous and asynchronous methods, errors may have any of the following `err.code` values:
+
+- `MODULE_NOT_FOUND`: the given path string (`id`) could not be resolved to a module
+- `INVALID_BASEDIR`: the specified `opts.basedir` doesn't exist, or is not a directory
+- `INVALID_PACKAGE_MAIN`: a `package.json` was encountered with an invalid `main` property (eg. not a string)
+
+## resolve(id, opts={}, cb)
+
+Asynchronously resolve the module path string `id` into `cb(err, res [, pkg])`, where `pkg` (if defined) is the data from `package.json`.
+
+options are:
+
+* opts.basedir - directory to begin resolving from
+
+* opts.package - `package.json` data applicable to the module being loaded
+
+* opts.extensions - array of file extensions to search in order
+
+* opts.includeCoreModules - set to `false` to exclude node core modules (e.g. `fs`) from the search
+
+* opts.readFile - how to read files asynchronously
+
+* opts.isFile - function to asynchronously test whether a file exists
+
+* opts.isDirectory - function to asynchronously test whether a file exists and is a directory
+
+* opts.realpath - function to asynchronously resolve a potential symlink to its real path
+
+* `opts.readPackage(readFile, pkgfile, cb)` - function to asynchronously read and parse a package.json file
+  * readFile - the passed `opts.readFile` or `fs.readFile` if not specified
+  * pkgfile - path to package.json
+  * cb - callback
+
+* `opts.packageFilter(pkg, pkgfile, dir)` - transform the parsed package.json contents before looking at the "main" field
+  * pkg - package data
+  * pkgfile - path to package.json
+  * dir - directory that contains package.json
+
+* `opts.pathFilter(pkg, path, relativePath)` - transform a path within a package
+  * pkg - package data
+  * path - the path being resolved
+  * relativePath - the path relative from the package.json location
+  * returns - a relative path that will be joined from the package.json location
+
+* opts.paths - require.paths array to use if nothing is found on the normal `node_modules` recursive walk (probably don't use this)
+
+  For advanced users, `paths` can also be a `opts.paths(request, start, opts)` function
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getNodeModulesDirs - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* `opts.packageIterator(request, start, opts)` - return the list of candidate paths where the packages sources may be found (probably don't use this)
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getPackageCandidates - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* opts.moduleDirectory - directory (or directories) in which to recursively look for modules. default: `"node_modules"`
+
+* opts.preserveSymlinks - if true, doesn't resolve `basedir` to real path before resolving.
+This is the way Node resolves dependencies when executed with the [--preserve-symlinks](https://nodejs.org/api/all.html#cli_preserve_symlinks) flag.
+**Note:** this property is currently `true` by default but it will be changed to
+`false` in the next major version because *Node's resolution algorithm does not preserve symlinks by default*.
+
+default `opts` values:
+
+```js
+{
+    paths: [],
+    basedir: __dirname,
+    extensions: ['.js'],
+    includeCoreModules: true,
+    readFile: fs.readFile,
+    isFile: function isFile(file, cb) {
+        fs.stat(file, function (err, stat) {
+            if (!err) {
+                return cb(null, stat.isFile() || stat.isFIFO());
+            }
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+            return cb(err);
+        });
+    },
+    isDirectory: function isDirectory(dir, cb) {
+        fs.stat(dir, function (err, stat) {
+            if (!err) {
+                return cb(null, stat.isDirectory());
+            }
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+            return cb(err);
+        });
+    },
+    realpath: function realpath(file, cb) {
+        var realpath = typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
+        realpath(file, function (realPathErr, realPath) {
+            if (realPathErr && realPathErr.code !== 'ENOENT') cb(realPathErr);
+            else cb(null, realPathErr ? file : realPath);
+        });
+    },
+    readPackage: function defaultReadPackage(readFile, pkgfile, cb) {
+        readFile(pkgfile, function (readFileErr, body) {
+            if (readFileErr) cb(readFileErr);
+            else {
+                try {
+                    var pkg = JSON.parse(body);
+                    cb(null, pkg);
+                } catch (jsonErr) {
+                    cb(null);
+                }
+            }
+        });
+    },
+    moduleDirectory: 'node_modules',
+    preserveSymlinks: true
+}
+```
+
+## resolve.sync(id, opts)
+
+Synchronously resolve the module path string `id`, returning the result and
+throwing an error when `id` can't be resolved.
+
+options are:
+
+* opts.basedir - directory to begin resolving from
+
+* opts.extensions - array of file extensions to search in order
+
+* opts.includeCoreModules - set to `false` to exclude node core modules (e.g. `fs`) from the search
+
+* opts.readFileSync - how to read files synchronously
+
+* opts.isFile - function to synchronously test whether a file exists
+
+* opts.isDirectory - function to synchronously test whether a file exists and is a directory
+
+* opts.realpathSync - function to synchronously resolve a potential symlink to its real path
+
+* `opts.readPackageSync(readFileSync, pkgfile)` - function to synchronously read and parse a package.json file
+  * readFileSync - the passed `opts.readFileSync` or `fs.readFileSync` if not specified
+  * pkgfile - path to package.json
+
+* `opts.packageFilter(pkg, dir)` - transform the parsed package.json contents before looking at the "main" field
+  * pkg - package data
+  * dir - directory that contains package.json (Note: the second argument will change to "pkgfile" in v2)
+
+* `opts.pathFilter(pkg, path, relativePath)` - transform a path within a package
+  * pkg - package data
+  * path - the path being resolved
+  * relativePath - the path relative from the package.json location
+  * returns - a relative path that will be joined from the package.json location
+
+* opts.paths - require.paths array to use if nothing is found on the normal `node_modules` recursive walk (probably don't use this)
+
+  For advanced users, `paths` can also be a `opts.paths(request, start, opts)` function
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getNodeModulesDirs - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* `opts.packageIterator(request, start, opts)` - return the list of candidate paths where the packages sources may be found (probably don't use this)
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getPackageCandidates - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* opts.moduleDirectory - directory (or directories) in which to recursively look for modules. default: `"node_modules"`
+
+* opts.preserveSymlinks - if true, doesn't resolve `basedir` to real path before resolving.
+This is the way Node resolves dependencies when executed with the [--preserve-symlinks](https://nodejs.org/api/all.html#cli_preserve_symlinks) flag.
+**Note:** this property is currently `true` by default but it will be changed to
+`false` in the next major version because *Node's resolution algorithm does not preserve symlinks by default*.
+
+default `opts` values:
+
+```js
+{
+    paths: [],
+    basedir: __dirname,
+    extensions: ['.js'],
+    includeCoreModules: true,
+    readFileSync: fs.readFileSync,
+    isFile: function isFile(file) {
+        try {
+            var stat = fs.statSync(file);
+        } catch (e) {
+            if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+            throw e;
+        }
+        return stat.isFile() || stat.isFIFO();
+    },
+    isDirectory: function isDirectory(dir) {
+        try {
+            var stat = fs.statSync(dir);
+        } catch (e) {
+            if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+            throw e;
+        }
+        return stat.isDirectory();
+    },
+    realpathSync: function realpathSync(file) {
+        try {
+            var realpath = typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
+            return realpath(file);
+        } catch (realPathErr) {
+            if (realPathErr.code !== 'ENOENT') {
+                throw realPathErr;
+            }
+        }
+        return file;
+    },
+    readPackageSync: function defaultReadPackageSync(readFileSync, pkgfile) {
+        var body = readFileSync(pkgfile);
+        try {
+            var pkg = JSON.parse(body);
+            return pkg;
+        } catch (jsonErr) {}
+    },
+    moduleDirectory: 'node_modules',
+    preserveSymlinks: true
+}
+```
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```sh
+npm install resolve
+```
+
+# license
+
+MIT
+
+[1]: https://npmjs.org/package/resolve
+[2]: https://versionbadg.es/browserify/resolve.svg
+[5]: https://david-dm.org/browserify/resolve.svg
+[6]: https://david-dm.org/browserify/resolve
+[7]: https://david-dm.org/browserify/resolve/dev-status.svg
+[8]: https://david-dm.org/browserify/resolve#info=devDependencies
+[11]: https://nodei.co/npm/resolve.png?downloads=true&stars=true
+[license-image]: https://img.shields.io/npm/l/resolve.svg
+[license-url]: LICENSE
+[downloads-image]: https://img.shields.io/npm/dm/resolve.svg
+[downloads-url]: https://npm-stat.com/charts.html?package=resolve
+[codecov-image]: https://codecov.io/gh/browserify/resolve/branch/main/graphs/badge.svg
+[codecov-url]: https://app.codecov.io/gh/browserify/resolve/
+[actions-image]: https://img.shields.io/github/check-runs/browserify/resolve/main
+[actions-url]: https://github.com/browserify/resolve/actions
diff --git a/tools/ui/node_modules/resolve/sync.js b/tools/ui/node_modules/resolve/sync.js
new file mode 100644
index 0000000000000000000000000000000000000000..cd0ee040177e92c676b1a063406c743289719bd0
--- /dev/null
+++ b/tools/ui/node_modules/resolve/sync.js
@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/sync');
diff --git a/tools/ui/node_modules/resolve/test/core.js b/tools/ui/node_modules/resolve/test/core.js
new file mode 100644
index 0000000000000000000000000000000000000000..a477adc5ce2a4464362d617a21604b367a8d9718
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/core.js
@@ -0,0 +1,88 @@
+var test = require('tape');
+var keys = require('object-keys');
+var semver = require('semver');
+
+var resolve = require('../');
+
+var brokenNode = semver.satisfies(process.version, '11.11 - 11.13');
+
+test('core modules', function (t) {
+    t.test('isCore()', function (st) {
+        st.ok(resolve.isCore('fs'));
+        st.ok(resolve.isCore('net'));
+        st.ok(resolve.isCore('http'));
+
+        st.ok(!resolve.isCore('seq'));
+        st.ok(!resolve.isCore('../'));
+
+        st.ok(!resolve.isCore('toString'));
+
+        st.end();
+    });
+
+    t.test('core list', function (st) {
+        var cores = keys(resolve.core);
+        st.plan(cores.length);
+
+        for (var i = 0; i < cores.length; ++i) {
+            var mod = cores[i];
+            // note: this must be require, not require.resolve, due to https://github.com/nodejs/node/issues/43274
+            var requireFunc = function () { require(mod); }; // eslint-disable-line no-loop-func
+            t.comment(mod + ': ' + resolve.core[mod]);
+            if (resolve.core[mod]) {
+                st.doesNotThrow(requireFunc, mod + ' supported; requiring does not throw');
+            } else if (brokenNode) {
+                st.ok(true, 'this version of node is broken: attempting to require things that fail to resolve breaks "home_paths" tests');
+            } else {
+                st.throws(requireFunc, mod + ' not supported; requiring throws');
+            }
+        }
+
+        st.end();
+    });
+
+    t.test('core via repl module', { skip: !resolve.core.repl }, function (st) {
+        var libs = require('repl')._builtinLibs; // eslint-disable-line no-underscore-dangle
+        if (!libs) {
+            st.skip('module.builtinModules does not exist');
+            return st.end();
+        }
+        for (var i = 0; i < libs.length; ++i) {
+            var mod = libs[i];
+            st.ok(resolve.core[mod], mod + ' is a core module');
+            st.doesNotThrow(
+                function () { require(mod); }, // eslint-disable-line no-loop-func
+                'requiring ' + mod + ' does not throw'
+            );
+        }
+        st.end();
+    });
+
+    t.test('core via builtinModules list', { skip: !resolve.core.module }, function (st) {
+        var libs = require('module').builtinModules;
+        if (!libs) {
+            st.skip('module.builtinModules does not exist');
+            return st.end();
+        }
+        var blacklist = [
+            '_debug_agent',
+            'v8/tools/tickprocessor-driver',
+            'v8/tools/SourceMap',
+            'v8/tools/tickprocessor',
+            'v8/tools/profile'
+        ];
+        for (var i = 0; i < libs.length; ++i) {
+            var mod = libs[i];
+            if (blacklist.indexOf(mod) === -1) {
+                st.ok(resolve.core[mod], mod + ' is a core module');
+                st.doesNotThrow(
+                    function () { require(mod); }, // eslint-disable-line no-loop-func
+                    'requiring ' + mod + ' does not throw'
+                );
+            }
+        }
+        st.end();
+    });
+
+    t.end();
+});
diff --git a/tools/ui/node_modules/resolve/test/default_paths.js b/tools/ui/node_modules/resolve/test/default_paths.js
new file mode 100644
index 0000000000000000000000000000000000000000..a8c3d73f7f808e861cb6494b73d411739b41a2bc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/default_paths.js
@@ -0,0 +1,49 @@
+'use strict';
+
+var path = require('path');
+var test = require('tape');
+var mockProperty = require('mock-property');
+
+var homedirPath = require.resolve('../lib/homedir');
+var asyncPath = require.resolve('../async');
+var libAsyncPath = require.resolve('../lib/async');
+var syncPath = require.resolve('../sync');
+var libSyncPath = require.resolve('../lib/sync');
+
+function mockNullHomedir(t) {
+    t.teardown(mockProperty(require.cache, homedirPath, {
+        value: { id: homedirPath, filename: homedirPath, loaded: true, exports: function () { return null; } }
+    }));
+}
+
+test('async: null homedir does not throw', function (t) {
+    t.plan(2);
+
+    mockNullHomedir(t);
+    t.teardown(mockProperty(require.cache, asyncPath, { 'delete': true }));
+    t.teardown(mockProperty(require.cache, libAsyncPath, { 'delete': true }));
+
+    var resolve = require('../lib/async');
+
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./baz', { basedir: dir }, function (err, res) {
+        t.error(err, 'no error');
+        t.equal(res, path.join(dir, 'baz', 'quux.js'), 'resolves correctly with null homedir');
+    });
+});
+
+test('sync: null homedir does not throw', function (t) {
+    mockNullHomedir(t);
+    t.teardown(mockProperty(require.cache, syncPath, { 'delete': true }));
+    t.teardown(mockProperty(require.cache, libSyncPath, { 'delete': true }));
+
+    var resolveSync = require('../lib/sync');
+
+    var dir = path.join(__dirname, 'resolver');
+
+    var res = resolveSync('./baz', { basedir: dir });
+    t.equal(res, path.join(dir, 'baz', 'quux.js'), 'resolves correctly with null homedir');
+
+    t.end();
+});
diff --git a/tools/ui/node_modules/resolve/test/dotdot.js b/tools/ui/node_modules/resolve/test/dotdot.js
new file mode 100644
index 0000000000000000000000000000000000000000..30806659be2ef27d410722636d6f79c8f8e999b0
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/dotdot.js
@@ -0,0 +1,29 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('dotdot', function (t) {
+    t.plan(4);
+    var dir = path.join(__dirname, '/dotdot/abc');
+
+    resolve('..', { basedir: dir }, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(__dirname, 'dotdot/index.js'));
+    });
+
+    resolve('.', { basedir: dir }, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, 'index.js'));
+    });
+});
+
+test('dotdot sync', function (t) {
+    t.plan(2);
+    var dir = path.join(__dirname, '/dotdot/abc');
+
+    var a = resolve.sync('..', { basedir: dir });
+    t.equal(a, path.join(__dirname, 'dotdot/index.js'));
+
+    var b = resolve.sync('.', { basedir: dir });
+    t.equal(b, path.join(dir, 'index.js'));
+});
diff --git a/tools/ui/node_modules/resolve/test/dotdot/abc/index.js b/tools/ui/node_modules/resolve/test/dotdot/abc/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..67f2534ebf90dcc4c2c1c13ce3ab52c41f4d2ed9
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/dotdot/abc/index.js
@@ -0,0 +1,2 @@
+var x = require('..');
+console.log(x);
diff --git a/tools/ui/node_modules/resolve/test/dotdot/index.js b/tools/ui/node_modules/resolve/test/dotdot/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..643f9fcc6a6a7cf025dcc86559e83d00b993ed96
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/dotdot/index.js
@@ -0,0 +1 @@
+module.exports = 'whatever';
diff --git a/tools/ui/node_modules/resolve/test/faulty_basedir.js b/tools/ui/node_modules/resolve/test/faulty_basedir.js
new file mode 100644
index 0000000000000000000000000000000000000000..5f2141a67267bceaf743ab292ca8e7bebb2b6bbc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/faulty_basedir.js
@@ -0,0 +1,29 @@
+var test = require('tape');
+var path = require('path');
+var resolve = require('../');
+
+test('faulty basedir must produce error in windows', { skip: process.platform !== 'win32' }, function (t) {
+    t.plan(1);
+
+    var resolverDir = 'C:\\a\\b\\c\\d';
+
+    resolve('tape/lib/test.js', { basedir: resolverDir }, function (err, res, pkg) {
+        t.equal(!!err, true);
+    });
+});
+
+test('non-existent basedir should not throw when preserveSymlinks is false', function (t) {
+    t.plan(2);
+
+    var opts = {
+        basedir: path.join(path.sep, 'unreal', 'path', 'that', 'does', 'not', 'exist'),
+        preserveSymlinks: false
+    };
+
+    var module = './dotdot/abc';
+
+    resolve(module, opts, function (err, res) {
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+        t.equal(res, undefined);
+    });
+});
diff --git a/tools/ui/node_modules/resolve/test/filter.js b/tools/ui/node_modules/resolve/test/filter.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f8cccdb2f59f3ea03a27151da52f73ed9f068de
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/filter.js
@@ -0,0 +1,34 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('filter', function (t) {
+    t.plan(4);
+    var dir = path.join(__dirname, 'resolver');
+    var packageFilterArgs;
+    resolve('./baz', {
+        basedir: dir,
+        packageFilter: function (pkg, pkgfile) {
+            pkg.main = 'doom'; // eslint-disable-line no-param-reassign
+            packageFilterArgs = [pkg, pkgfile];
+            return pkg;
+        }
+    }, function (err, res, pkg) {
+        if (err) t.fail(err);
+
+        t.equal(res, path.join(dir, 'baz/doom.js'), 'changing the package "main" works');
+
+        var packageData = packageFilterArgs[0];
+        t.equal(pkg, packageData, 'first packageFilter argument is "pkg"');
+        t.equal(packageData.main, 'doom', 'package "main" was altered');
+
+        var packageFile = packageFilterArgs[1];
+        t.equal(
+            packageFile,
+            path.join(dir, 'baz/package.json'),
+            'second packageFilter argument is "pkgfile"'
+        );
+
+        t.end();
+    });
+});
diff --git a/tools/ui/node_modules/resolve/test/filter_sync.js b/tools/ui/node_modules/resolve/test/filter_sync.js
new file mode 100644
index 0000000000000000000000000000000000000000..8a43b9818973dfba95a2389f27e966ff4f315343
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/filter_sync.js
@@ -0,0 +1,33 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('filter', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    var packageFilterArgs;
+    var res = resolve.sync('./baz', {
+        basedir: dir,
+        // NOTE: in v2.x, this will be `pkg, pkgfile, dir`, but must remain "broken" here in v1.x for compatibility
+        packageFilter: function (pkg, /*pkgfile,*/ dir) { // eslint-disable-line spaced-comment
+            pkg.main = 'doom'; // eslint-disable-line no-param-reassign
+            packageFilterArgs = 'is 1.x' ? [pkg, dir] : [pkg, pkgfile, dir]; // eslint-disable-line no-constant-condition, no-undef
+            return pkg;
+        }
+    });
+
+    t.equal(res, path.join(dir, 'baz/doom.js'), 'changing the package "main" works');
+
+    var packageData = packageFilterArgs[0];
+    t.equal(packageData.main, 'doom', 'package "main" was altered');
+
+    if (!'is 1.x') { // eslint-disable-line no-constant-condition
+        var packageFile = packageFilterArgs[1];
+        t.equal(packageFile, path.join(dir, 'baz', 'package.json'), 'package.json path is correct');
+    }
+
+    var packageDir = packageFilterArgs['is 1.x' ? 1 : 2]; // eslint-disable-line no-constant-condition
+    // eslint-disable-next-line no-constant-condition
+    t.equal(packageDir, path.join(dir, 'baz'), ('is 1.x' ? 'second' : 'third') + ' packageFilter argument is "dir"');
+
+    t.end();
+});
diff --git a/tools/ui/node_modules/resolve/test/home_paths.js b/tools/ui/node_modules/resolve/test/home_paths.js
new file mode 100644
index 0000000000000000000000000000000000000000..3b8c9b32c87bd73fb2a3ec42494d13faae1594e4
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/home_paths.js
@@ -0,0 +1,127 @@
+'use strict';
+
+var fs = require('fs');
+var homedir = require('../lib/homedir');
+var path = require('path');
+
+var test = require('tape');
+var mkdirp = require('mkdirp');
+var rimraf = require('rimraf');
+var mv = require('mv');
+var copyDir = require('copy-dir');
+var tmp = require('tmp');
+
+var HOME = homedir();
+
+var hnm = path.join(HOME, '.node_modules');
+var hnl = path.join(HOME, '.node_libraries');
+
+var resolve = require('../async');
+
+function makeDir(t, dir, cb) {
+    mkdirp(dir, function (err) {
+        if (err) {
+            cb(err);
+        } else {
+            t.teardown(function cleanup() {
+                rimraf.sync(dir);
+            });
+            cb();
+        }
+    });
+}
+
+function makeTempDir(t, dir, cb) {
+    if (fs.existsSync(dir)) {
+        var tmpResult = tmp.dirSync();
+        t.teardown(tmpResult.removeCallback);
+        var backup = path.join(tmpResult.name, path.basename(dir));
+        mv(dir, backup, function (err) {
+            if (err) {
+                cb(err);
+            } else {
+                t.teardown(function () {
+                    mv(backup, dir, cb);
+                });
+                makeDir(t, dir, cb);
+            }
+        });
+    } else {
+        makeDir(t, dir, cb);
+    }
+}
+
+test('homedir module paths', function (t) {
+    t.plan(7);
+
+    makeTempDir(t, hnm, function (err) {
+        t.error(err, 'no error with HNM temp dir');
+        if (err) {
+            return t.end();
+        }
+
+        var bazHNMDir = path.join(hnm, 'baz');
+        var dotMainDir = path.join(hnm, 'dot_main');
+        copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNMDir);
+        copyDir.sync(path.join(__dirname, 'resolver/dot_main'), dotMainDir);
+
+        var bazPkg = { name: 'baz', main: 'quux.js' };
+        var dotMainPkg = { main: 'index' };
+
+        var bazHNMmain = path.join(bazHNMDir, 'quux.js');
+        t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+        var dotMainMain = path.join(dotMainDir, 'index.js');
+        t.equal(require.resolve('dot_main'), dotMainMain, 'sanity check: require.resolve finds `dot_main`');
+
+        makeTempDir(t, hnl, function (err) {
+            t.error(err, 'no error with HNL temp dir');
+            if (err) {
+                return t.end();
+            }
+            var bazHNLDir = path.join(hnl, 'baz');
+            copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNLDir);
+
+            var dotSlashMainDir = path.join(hnl, 'dot_slash_main');
+            var dotSlashMainMain = path.join(dotSlashMainDir, 'index.js');
+            var dotSlashMainPkg = { main: 'index' };
+            copyDir.sync(path.join(__dirname, 'resolver/dot_slash_main'), dotSlashMainDir);
+
+            t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+            t.equal(require.resolve('dot_slash_main'), dotSlashMainMain, 'sanity check: require.resolve finds HNL `dot_slash_main`');
+
+            t.test('with temp dirs', function (st) {
+                st.plan(3);
+
+                st.test('just in `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(3);
+
+                    resolve('dot_main', function (err, res, pkg) {
+                        s2t.error(err, 'no error resolving `dot_main`');
+                        s2t.equal(res, dotMainMain, '`dot_main` resolves in `$HOME/.node_modules`');
+                        s2t.deepEqual(pkg, dotMainPkg);
+                    });
+                });
+
+                st.test('just in `$HOME/.node_libraries`', function (s2t) {
+                    s2t.plan(3);
+
+                    resolve('dot_slash_main', function (err, res, pkg) {
+                        s2t.error(err, 'no error resolving `dot_slash_main`');
+                        s2t.equal(res, dotSlashMainMain, '`dot_slash_main` resolves in `$HOME/.node_libraries`');
+                        s2t.deepEqual(pkg, dotSlashMainPkg);
+                    });
+                });
+
+                st.test('in `$HOME/.node_libraries` and `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(3);
+
+                    resolve('baz', function (err, res, pkg) {
+                        s2t.error(err, 'no error resolving `baz`');
+                        s2t.equal(res, bazHNMmain, '`baz` resolves in `$HOME/.node_modules` when in both');
+                        s2t.deepEqual(pkg, bazPkg);
+                    });
+                });
+            });
+        });
+    });
+});
diff --git a/tools/ui/node_modules/resolve/test/home_paths_sync.js b/tools/ui/node_modules/resolve/test/home_paths_sync.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d2c56fd35d0a3ad072c3549f12695c93654aaed
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/home_paths_sync.js
@@ -0,0 +1,114 @@
+'use strict';
+
+var fs = require('fs');
+var homedir = require('../lib/homedir');
+var path = require('path');
+
+var test = require('tape');
+var mkdirp = require('mkdirp');
+var rimraf = require('rimraf');
+var mv = require('mv');
+var copyDir = require('copy-dir');
+var tmp = require('tmp');
+
+var HOME = homedir();
+
+var hnm = path.join(HOME, '.node_modules');
+var hnl = path.join(HOME, '.node_libraries');
+
+var resolve = require('../sync');
+
+function makeDir(t, dir, cb) {
+    mkdirp(dir, function (err) {
+        if (err) {
+            cb(err);
+        } else {
+            t.teardown(function cleanup() {
+                rimraf.sync(dir);
+            });
+            cb();
+        }
+    });
+}
+
+function makeTempDir(t, dir, cb) {
+    if (fs.existsSync(dir)) {
+        var tmpResult = tmp.dirSync();
+        t.teardown(tmpResult.removeCallback);
+        var backup = path.join(tmpResult.name, path.basename(dir));
+        mv(dir, backup, function (err) {
+            if (err) {
+                cb(err);
+            } else {
+                t.teardown(function () {
+                    mv(backup, dir, cb);
+                });
+                makeDir(t, dir, cb);
+            }
+        });
+    } else {
+        makeDir(t, dir, cb);
+    }
+}
+
+test('homedir module paths', function (t) {
+    t.plan(7);
+
+    makeTempDir(t, hnm, function (err) {
+        t.error(err, 'no error with HNM temp dir');
+        if (err) {
+            return t.end();
+        }
+
+        var bazHNMDir = path.join(hnm, 'baz');
+        var dotMainDir = path.join(hnm, 'dot_main');
+        copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNMDir);
+        copyDir.sync(path.join(__dirname, 'resolver/dot_main'), dotMainDir);
+
+        var bazHNMmain = path.join(bazHNMDir, 'quux.js');
+        t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+        var dotMainMain = path.join(dotMainDir, 'index.js');
+        t.equal(require.resolve('dot_main'), dotMainMain, 'sanity check: require.resolve finds `dot_main`');
+
+        makeTempDir(t, hnl, function (err) {
+            t.error(err, 'no error with HNL temp dir');
+            if (err) {
+                return t.end();
+            }
+            var bazHNLDir = path.join(hnl, 'baz');
+            copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNLDir);
+
+            var dotSlashMainDir = path.join(hnl, 'dot_slash_main');
+            var dotSlashMainMain = path.join(dotSlashMainDir, 'index.js');
+            copyDir.sync(path.join(__dirname, 'resolver/dot_slash_main'), dotSlashMainDir);
+
+            t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+            t.equal(require.resolve('dot_slash_main'), dotSlashMainMain, 'sanity check: require.resolve finds HNL `dot_slash_main`');
+
+            t.test('with temp dirs', function (st) {
+                st.plan(3);
+
+                st.test('just in `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(1);
+
+                    var res = resolve('dot_main');
+                    s2t.equal(res, dotMainMain, '`dot_main` resolves in `$HOME/.node_modules`');
+                });
+
+                st.test('just in `$HOME/.node_libraries`', function (s2t) {
+                    s2t.plan(1);
+
+                    var res = resolve('dot_slash_main');
+                    s2t.equal(res, dotSlashMainMain, '`dot_slash_main` resolves in `$HOME/.node_libraries`');
+                });
+
+                st.test('in `$HOME/.node_libraries` and `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(1);
+
+                    var res = resolve('baz');
+                    s2t.equal(res, bazHNMmain, '`baz` resolves in `$HOME/.node_modules` when in both');
+                });
+            });
+        });
+    });
+});
diff --git a/tools/ui/node_modules/resolve/test/homedir.js b/tools/ui/node_modules/resolve/test/homedir.js
new file mode 100644
index 0000000000000000000000000000000000000000..b64bce7250f2f8e1b3d44893f7ab03427875edbc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/homedir.js
@@ -0,0 +1,112 @@
+'use strict';
+
+var os = require('os');
+var test = require('tape');
+var mockProperty = require('mock-property');
+
+var envKeys = ['HOME', 'USERPROFILE', 'HOMEDRIVE', 'HOMEPATH', 'LOGNAME', 'USER', 'LNAME', 'USERNAME'];
+
+function mockEnv(t, key, value) {
+    var has = key in process.env;
+    var orig = process.env[key];
+    if (arguments.length > 2) {
+        process.env[key] = value;
+    } else {
+        delete process.env[key];
+    }
+    t.teardown(function () {
+        if (has) {
+            process.env[key] = orig;
+        } else {
+            delete process.env[key];
+        }
+    });
+}
+
+function clearEnv(t) {
+    for (var i = 0; i < envKeys.length; i++) {
+        mockEnv(t, envKeys[i]);
+    }
+}
+
+function getFallback(t) {
+    t.teardown(mockProperty(os, 'homedir', { value: undefined }));
+
+    var homedirPath = require.resolve('../lib/homedir');
+    t.teardown(mockProperty(require.cache, homedirPath, { 'delete': true }));
+
+    return require('../lib/homedir');
+}
+
+test('homedir fallback', function (t) {
+    t.test('win32: HOMEDRIVE without HOMEPATH does not produce a false concatenation', function (st) {
+        clearEnv(st);
+        st.teardown(mockProperty(process, 'platform', { value: 'win32' }));
+
+        var homedir = getFallback(st);
+
+        mockEnv(st, 'HOMEDRIVE', 'C:');
+
+        st.equal(homedir(), null, 'returns null when only HOMEDRIVE is set');
+
+        st.end();
+    });
+
+    t.test('win32: HOMEPATH without HOMEDRIVE does not produce a false concatenation', function (st) {
+        clearEnv(st);
+        st.teardown(mockProperty(process, 'platform', { value: 'win32' }));
+
+        var homedir = getFallback(st);
+
+        mockEnv(st, 'HOMEPATH', '\\Users\\foo');
+
+        st.equal(homedir(), null, 'returns null when only HOMEPATH is set');
+
+        st.end();
+    });
+
+    t.test('win32: HOMEDRIVE + HOMEPATH both set returns concatenation', function (st) {
+        clearEnv(st);
+        st.teardown(mockProperty(process, 'platform', { value: 'win32' }));
+
+        var homedir = getFallback(st);
+
+        mockEnv(st, 'HOMEDRIVE', 'C:');
+        mockEnv(st, 'HOMEPATH', '\\Users\\foo');
+
+        st.equal(homedir(), 'C:\\Users\\foo', 'returns concatenated drive and path');
+
+        st.end();
+    });
+
+    t.test('win32: USERPROFILE takes precedence over HOMEDRIVE+HOMEPATH', function (st) {
+        clearEnv(st);
+        st.teardown(mockProperty(process, 'platform', { value: 'win32' }));
+
+        var homedir = getFallback(st);
+
+        mockEnv(st, 'USERPROFILE', 'C:\\Users\\bar');
+        mockEnv(st, 'HOMEDRIVE', 'C:');
+        mockEnv(st, 'HOMEPATH', '\\Users\\foo');
+
+        st.equal(homedir(), 'C:\\Users\\bar', 'returns USERPROFILE');
+
+        st.end();
+    });
+
+    t.test('win32: falls back to HOME when HOMEDRIVE/HOMEPATH are partial', function (st) {
+        clearEnv(st);
+        st.teardown(mockProperty(process, 'platform', { value: 'win32' }));
+
+        var homedir = getFallback(st);
+
+        mockEnv(st, 'HOME', 'C:\\Users\\baz');
+        mockEnv(st, 'HOMEDRIVE', 'C:');
+
+        st.equal(homedir(), 'C:\\Users\\baz', 'falls back to HOME');
+
+        st.end();
+    });
+
+    t.end();
+});
diff --git a/tools/ui/node_modules/resolve/test/mock.js b/tools/ui/node_modules/resolve/test/mock.js
new file mode 100644
index 0000000000000000000000000000000000000000..2b95e38841f160d739c36462f05fc30cf779d058
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/mock.js
@@ -0,0 +1,353 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('mock', function (t) {
+    t.plan(8);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    resolve('./baz', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/baz.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('./baz.js', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/baz.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('baz', opts('/foo/bar'), function (err, res) {
+        t.equal(err.message, "Cannot find module 'baz' from '" + path.resolve('/foo/bar') + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    resolve('../baz', opts('/foo/bar'), function (err, res) {
+        t.equal(err.message, "Cannot find module '../baz' from '" + path.resolve('/foo/bar') + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+});
+
+test('mock from package', function (t) {
+    t.plan(8);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, file));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            'package': { main: 'bar' },
+            readFile: function (file, cb) {
+                cb(null, files[file]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    resolve('./baz', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/baz.js'));
+        t.equal(pkg && pkg.main, 'bar');
+    });
+
+    resolve('./baz.js', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/baz.js'));
+        t.equal(pkg && pkg.main, 'bar');
+    });
+
+    resolve('baz', opts('/foo/bar'), function (err, res) {
+        t.equal(err.message, "Cannot find module 'baz' from '" + path.resolve('/foo/bar') + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    resolve('../baz', opts('/foo/bar'), function (err, res) {
+        t.equal(err.message, "Cannot find module '../baz' from '" + path.resolve('/foo/bar') + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+});
+
+test('mock package', function (t) {
+    t.plan(2);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    resolve('bar', opts('/foo'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/node_modules/bar/baz.js'));
+        t.equal(pkg && pkg.main, './baz.js');
+    });
+});
+
+test('mock package from package', function (t) {
+    t.plan(2);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            'package': { main: 'bar' },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    resolve('bar', opts('/foo'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/node_modules/bar/baz.js'));
+        t.equal(pkg && pkg.main, './baz.js');
+    });
+});
+
+test('symlinked', function (t) {
+    t.plan(4);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/bar/symlinked/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+    dirs[path.resolve('/foo/bar/symlinked')] = true;
+
+    function opts(basedir) {
+        return {
+            preserveSymlinks: false,
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                var resolved = path.resolve(file);
+
+                if (resolved.indexOf('symlinked') >= 0) {
+                    cb(null, resolved);
+                    return;
+                }
+
+                var ext = path.extname(resolved);
+
+                if (ext) {
+                    var dir = path.dirname(resolved);
+                    var base = path.basename(resolved);
+                    cb(null, path.join(dir, 'symlinked', base));
+                } else {
+                    cb(null, path.join(resolved, 'symlinked'));
+                }
+            }
+        };
+    }
+
+    resolve('./baz', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/symlinked/baz.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('./baz.js', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/symlinked/baz.js'));
+        t.equal(pkg, undefined);
+    });
+});
+
+test('readPackage', function (t) {
+    t.plan(4);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/something-else.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'boop';
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            'package': { main: 'bar' },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    t.test('with readFile', function (st) {
+        st.plan(3);
+
+        resolve('bar', opts('/foo'), function (err, res, pkg) {
+            st.error(err);
+            st.equal(res, path.resolve('/foo/node_modules/bar/baz.js'));
+            st.equal(pkg && pkg.main, './baz.js');
+        });
+    });
+
+    function readPackage(readFile, file, cb) {
+        var barPackage = path.join('bar', 'package.json');
+        if (file.slice(-barPackage.length) === barPackage) {
+            cb(null, { main: './something-else.js' });
+        } else {
+            cb(null, JSON.parse(files[path.resolve(file)]));
+        }
+    }
+
+    t.test('with readPackage', function (st) {
+        st.plan(3);
+
+        var options = opts('/foo');
+        delete options.readFile;
+        options.readPackage = readPackage;
+        resolve('bar', options, function (err, res, pkg) {
+            st.error(err);
+            st.equal(res, path.resolve('/foo/node_modules/bar/something-else.js'));
+            st.equal(pkg && pkg.main, './something-else.js');
+        });
+    });
+
+    t.test('with readFile and readPackage', function (st) {
+        st.plan(1);
+
+        var options = opts('/foo');
+        options.readPackage = readPackage;
+        resolve('bar', options, function (err) {
+            st.throws(function () { throw err; }, TypeError, 'errors when both readFile and readPackage are provided');
+        });
+    });
+
+    t.test('readPackage error in loadpkg does not invoke callback twice', function (st) {
+        st.plan(1);
+
+        var callCount = 0;
+        var readPackageError = new Error('read package error');
+
+        function failReadPackage(rf, file, cb) {
+            cb(readPackageError);
+        }
+
+        var relFiles = {};
+        relFiles[path.resolve('/foo/bar/baz.js')] = 'beep';
+        relFiles[path.resolve('/foo/bar/package.json')] = '{}';
+
+        var relDirs = {};
+        relDirs[path.resolve('/foo/bar')] = true;
+
+        resolve('./baz', {
+            basedir: path.resolve('/foo/bar'),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(relFiles, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!relDirs[path.resolve(dir)]);
+            },
+            readPackage: failReadPackage,
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        }, function () {
+            callCount += 1;
+        });
+
+        setTimeout(function () {
+            st.equal(callCount, 1, 'callback is invoked exactly once');
+        }, 50);
+    });
+});
diff --git a/tools/ui/node_modules/resolve/test/mock_sync.js b/tools/ui/node_modules/resolve/test/mock_sync.js
new file mode 100644
index 0000000000000000000000000000000000000000..3456cab00383f64f262831b39bec083adcd75ae1
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/mock_sync.js
@@ -0,0 +1,234 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('mock', function (t) {
+    t.plan(4);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file) {
+                return Object.prototype.hasOwnProperty.call(files, path.resolve(file));
+            },
+            isDirectory: function (dir) {
+                return !!dirs[path.resolve(dir)];
+            },
+            readFileSync: function (file) {
+                return files[path.resolve(file)];
+            },
+            realpathSync: function (file) {
+                return file;
+            }
+        };
+    }
+
+    t.equal(
+        resolve.sync('./baz', opts('/foo/bar')),
+        path.resolve('/foo/bar/baz.js')
+    );
+
+    t.equal(
+        resolve.sync('./baz.js', opts('/foo/bar')),
+        path.resolve('/foo/bar/baz.js')
+    );
+
+    t.throws(function () {
+        resolve.sync('baz', opts('/foo/bar'));
+    });
+
+    t.throws(function () {
+        resolve.sync('../baz', opts('/foo/bar'));
+    });
+});
+
+test('mock package', function (t) {
+    t.plan(1);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file) {
+                return Object.prototype.hasOwnProperty.call(files, path.resolve(file));
+            },
+            isDirectory: function (dir) {
+                return !!dirs[path.resolve(dir)];
+            },
+            readFileSync: function (file) {
+                return files[path.resolve(file)];
+            },
+            realpathSync: function (file) {
+                return file;
+            }
+        };
+    }
+
+    t.equal(
+        resolve.sync('bar', opts('/foo')),
+        path.resolve('/foo/node_modules/bar/baz.js')
+    );
+});
+
+test('symlinked', function (t) {
+    t.plan(2);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/bar/symlinked/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+    dirs[path.resolve('/foo/bar/symlinked')] = true;
+
+    function opts(basedir) {
+        return {
+            preserveSymlinks: false,
+            basedir: path.resolve(basedir),
+            isFile: function (file) {
+                return Object.prototype.hasOwnProperty.call(files, path.resolve(file));
+            },
+            isDirectory: function (dir) {
+                return !!dirs[path.resolve(dir)];
+            },
+            readFileSync: function (file) {
+                return files[path.resolve(file)];
+            },
+            realpathSync: function (file) {
+                var resolved = path.resolve(file);
+
+                if (resolved.indexOf('symlinked') >= 0) {
+                    return resolved;
+                }
+
+                var ext = path.extname(resolved);
+
+                if (ext) {
+                    var dir = path.dirname(resolved);
+                    var base = path.basename(resolved);
+                    return path.join(dir, 'symlinked', base);
+                }
+                return path.join(resolved, 'symlinked');
+            }
+        };
+    }
+
+    t.equal(
+        resolve.sync('./baz', opts('/foo/bar')),
+        path.resolve('/foo/bar/symlinked/baz.js')
+    );
+
+    t.equal(
+        resolve.sync('./baz.js', opts('/foo/bar')),
+        path.resolve('/foo/bar/symlinked/baz.js')
+    );
+});
+
+test('readPackageSync', function (t) {
+    t.plan(4);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/something-else.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'boop';
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir, useReadPackage) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file) {
+                return Object.prototype.hasOwnProperty.call(files, path.resolve(file));
+            },
+            isDirectory: function (dir) {
+                return !!dirs[path.resolve(dir)];
+            },
+            readFileSync: useReadPackage ? null : function (file) {
+                return files[path.resolve(file)];
+            },
+            realpathSync: function (file) {
+                return file;
+            }
+        };
+    }
+    t.test('with readFile', function (st) {
+        st.plan(1);
+
+        st.equal(
+            resolve.sync('bar', opts('/foo')),
+            path.resolve('/foo/node_modules/bar/baz.js')
+        );
+    });
+
+    function readPackageSync(readFileSync, file) {
+        if (file.indexOf(path.join('bar', 'package.json')) >= 0) {
+            return { main: './something-else.js' };
+        }
+        return JSON.parse(files[path.resolve(file)]);
+    }
+
+    t.test('with readPackage', function (st) {
+        st.plan(1);
+
+        var options = opts('/foo');
+        delete options.readFileSync;
+        options.readPackageSync = readPackageSync;
+
+        st.equal(
+            resolve.sync('bar', options),
+            path.resolve('/foo/node_modules/bar/something-else.js')
+        );
+    });
+
+    t.test('with readFile and readPackage', function (st) {
+        st.plan(1);
+
+        var options = opts('/foo');
+        options.readPackageSync = readPackageSync;
+        st.throws(
+            function () { resolve.sync('bar', options); },
+            TypeError,
+            'errors when both readFile and readPackage are provided'
+        );
+    });
+
+    t.test('readPackageSync error propagates correctly', function (st) {
+        st.plan(1);
+
+        var readPackageError = new Error('read package error');
+
+        function failReadPackageSync() {
+            throw readPackageError;
+        }
+
+        var options = opts('/foo');
+        delete options.readFileSync;
+        options.readPackageSync = failReadPackageSync;
+
+        st.throws(
+            function () { resolve.sync('bar', options); },
+            readPackageError,
+            'readPackageSync error is thrown'
+        );
+    });
+});
+
diff --git a/tools/ui/node_modules/resolve/test/module_dir.js b/tools/ui/node_modules/resolve/test/module_dir.js
new file mode 100644
index 0000000000000000000000000000000000000000..b50e5bb1751d69694deaae36d5f0bc6691498008
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/module_dir.js
@@ -0,0 +1,56 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('moduleDirectory strings', function (t) {
+    t.plan(4);
+    var dir = path.join(__dirname, 'module_dir');
+    var xopts = {
+        basedir: dir,
+        moduleDirectory: 'xmodules'
+    };
+    resolve('aaa', xopts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/xmodules/aaa/index.js'));
+    });
+
+    var yopts = {
+        basedir: dir,
+        moduleDirectory: 'ymodules'
+    };
+    resolve('aaa', yopts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/ymodules/aaa/index.js'));
+    });
+});
+
+test('moduleDirectory array', function (t) {
+    t.plan(6);
+    var dir = path.join(__dirname, 'module_dir');
+    var aopts = {
+        basedir: dir,
+        moduleDirectory: ['xmodules', 'ymodules', 'zmodules']
+    };
+    resolve('aaa', aopts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/xmodules/aaa/index.js'));
+    });
+
+    var bopts = {
+        basedir: dir,
+        moduleDirectory: ['zmodules', 'ymodules', 'xmodules']
+    };
+    resolve('aaa', bopts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/ymodules/aaa/index.js'));
+    });
+
+    var copts = {
+        basedir: dir,
+        moduleDirectory: ['xmodules', 'ymodules', 'zmodules']
+    };
+    resolve('bbb', copts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/zmodules/bbb/main.js'));
+    });
+});
diff --git a/tools/ui/node_modules/resolve/test/module_dir/xmodules/aaa/index.js b/tools/ui/node_modules/resolve/test/module_dir/xmodules/aaa/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..dd7cf7b2d022daae3c3f7628fcfb2f8bf186efac
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/module_dir/xmodules/aaa/index.js
@@ -0,0 +1 @@
+module.exports = function (x) { return x * 100; };
diff --git a/tools/ui/node_modules/resolve/test/module_dir/ymodules/aaa/index.js b/tools/ui/node_modules/resolve/test/module_dir/ymodules/aaa/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..ef2d4d4bf76e61fdfe16ef406c9752c6435138f3
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/module_dir/ymodules/aaa/index.js
@@ -0,0 +1 @@
+module.exports = function (x) { return x + 100; };
diff --git a/tools/ui/node_modules/resolve/test/module_dir/zmodules/bbb/main.js b/tools/ui/node_modules/resolve/test/module_dir/zmodules/bbb/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..e8ba629936a7ad11134ac826edfad2379759c7cb
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/module_dir/zmodules/bbb/main.js
@@ -0,0 +1 @@
+module.exports = function (n) { return n * 111; };
diff --git a/tools/ui/node_modules/resolve/test/module_dir/zmodules/bbb/package.json b/tools/ui/node_modules/resolve/test/module_dir/zmodules/bbb/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..c13b8cf6acfd3344bc2c7969a31d930d933fdf22
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/module_dir/zmodules/bbb/package.json
@@ -0,0 +1,3 @@
+{
+  "main": "main.js"
+}
diff --git a/tools/ui/node_modules/resolve/test/node-modules-paths.js b/tools/ui/node_modules/resolve/test/node-modules-paths.js
new file mode 100644
index 0000000000000000000000000000000000000000..ed0a8b822d323c2616f20d63baa21c2ec638f704
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/node-modules-paths.js
@@ -0,0 +1,143 @@
+var test = require('tape');
+var path = require('path');
+var parse = path.parse || require('path-parse');
+var keys = require('object-keys');
+
+var nodeModulesPaths = require('../lib/node-modules-paths');
+
+function verifyDirs(t, start, dirs, moduleDirectories, paths) {
+    var moduleDirs = [].concat(moduleDirectories || 'node_modules');
+    if (paths) {
+        for (var k = 0; k < paths.length; ++k) {
+            moduleDirs.push(path.basename(paths[k]));
+        }
+    }
+
+    var foundModuleDirs = {};
+    var uniqueDirs = {};
+    var parsedDirs = {};
+    for (var i = 0; i < dirs.length; ++i) {
+        var parsed = parse(dirs[i]);
+        if (!foundModuleDirs[parsed.base]) { foundModuleDirs[parsed.base] = 0; }
+        foundModuleDirs[parsed.base] += 1;
+        parsedDirs[parsed.dir] = true;
+        uniqueDirs[dirs[i]] = true;
+    }
+    t.equal(keys(parsedDirs).length >= start.split(path.sep).length, true, 'there are >= dirs than "start" has');
+    var foundModuleDirNames = keys(foundModuleDirs);
+    t.deepEqual(foundModuleDirNames, moduleDirs, 'all desired module dirs were found');
+    t.equal(keys(uniqueDirs).length, dirs.length, 'all dirs provided were unique');
+
+    var counts = {};
+    for (var j = 0; j < foundModuleDirNames.length; ++j) {
+        counts[foundModuleDirs[j]] = true;
+    }
+    t.equal(keys(counts).length, 1, 'all found module directories had the same count');
+}
+
+test('node-modules-paths', function (t) {
+    t.test('no options', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var dirs = nodeModulesPaths(start);
+
+        verifyDirs(t, start, dirs);
+
+        t.end();
+    });
+
+    t.test('empty options', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var dirs = nodeModulesPaths(start, {});
+
+        verifyDirs(t, start, dirs);
+
+        t.end();
+    });
+
+    t.test('with paths=array option', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var paths = ['a', 'b'];
+        var dirs = nodeModulesPaths(start, { paths: paths });
+
+        verifyDirs(t, start, dirs, null, paths);
+
+        t.end();
+    });
+
+    t.test('with paths=function option', function (t) {
+        function paths(request, absoluteStart, getNodeModulesDirs, opts) {
+            return getNodeModulesDirs().concat(path.join(absoluteStart, 'not node modules', request));
+        }
+
+        var start = path.join(__dirname, 'resolver');
+        var dirs = nodeModulesPaths(start, { paths: paths }, 'pkg');
+
+        verifyDirs(t, start, dirs, null, [path.join(start, 'not node modules', 'pkg')]);
+
+        t.end();
+    });
+
+    t.test('with paths=function skipping node modules resolution', function (t) {
+        function paths(request, absoluteStart, getNodeModulesDirs, opts) {
+            return [];
+        }
+        var start = path.join(__dirname, 'resolver');
+        var dirs = nodeModulesPaths(start, { paths: paths });
+        t.deepEqual(dirs, [], 'no node_modules was computed');
+        t.end();
+    });
+
+    t.test('with moduleDirectory option', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var moduleDirectory = 'not node modules';
+        var dirs = nodeModulesPaths(start, { moduleDirectory: moduleDirectory });
+
+        verifyDirs(t, start, dirs, moduleDirectory);
+
+        t.end();
+    });
+
+    t.test('with 1 moduleDirectory and paths options', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var paths = ['a', 'b'];
+        var moduleDirectory = 'not node modules';
+        var dirs = nodeModulesPaths(start, { paths: paths, moduleDirectory: moduleDirectory });
+
+        verifyDirs(t, start, dirs, moduleDirectory, paths);
+
+        t.end();
+    });
+
+    t.test('with 1+ moduleDirectory and paths options', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var paths = ['a', 'b'];
+        var moduleDirectories = ['not node modules', 'other modules'];
+        var dirs = nodeModulesPaths(start, { paths: paths, moduleDirectory: moduleDirectories });
+
+        verifyDirs(t, start, dirs, moduleDirectories, paths);
+
+        t.end();
+    });
+
+    t.test('combine paths correctly on Windows', function (t) {
+        var start = 'C:\\Users\\username\\myProject\\src';
+        var paths = [];
+        var moduleDirectories = ['node_modules', start];
+        var dirs = nodeModulesPaths(start, { paths: paths, moduleDirectory: moduleDirectories });
+
+        t.equal(dirs.indexOf(path.resolve(start)) > -1, true, 'should contain start dir');
+
+        t.end();
+    });
+
+    t.test('combine paths correctly on non-Windows', { skip: process.platform === 'win32' }, function (t) {
+        var start = '/Users/username/git/myProject/src';
+        var paths = [];
+        var moduleDirectories = ['node_modules', '/Users/username/git/myProject/src'];
+        var dirs = nodeModulesPaths(start, { paths: paths, moduleDirectory: moduleDirectories });
+
+        t.equal(dirs.indexOf(path.resolve(start)) > -1, true, 'should contain start dir');
+
+        t.end();
+    });
+});
diff --git a/tools/ui/node_modules/resolve/test/node_path.js b/tools/ui/node_modules/resolve/test/node_path.js
new file mode 100644
index 0000000000000000000000000000000000000000..5ddd3101ba68837a696d4489be83582a6ac70190
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/node_path.js
@@ -0,0 +1,70 @@
+var fs = require('fs');
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('$NODE_PATH', function (t) {
+    t.plan(8);
+
+    function isDir(dir, cb) {
+        if (dir === '/node_path' || dir === 'node_path/x') {
+            return cb(null, true);
+        }
+        fs.stat(dir, function (err, stat) {
+            if (!err) {
+                return cb(null, stat.isDirectory());
+            }
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+            return cb(err);
+        });
+    }
+
+    resolve('aaa', {
+        paths: [
+            path.join(__dirname, '/node_path/x'),
+            path.join(__dirname, '/node_path/y')
+        ],
+        basedir: __dirname,
+        isDirectory: isDir
+    }, function (err, res) {
+        t.error(err);
+        t.equal(res, path.join(__dirname, '/node_path/x/aaa/index.js'), 'aaa resolves');
+    });
+
+    resolve('bbb', {
+        paths: [
+            path.join(__dirname, '/node_path/x'),
+            path.join(__dirname, '/node_path/y')
+        ],
+        basedir: __dirname,
+        isDirectory: isDir
+    }, function (err, res) {
+        t.error(err);
+        t.equal(res, path.join(__dirname, '/node_path/y/bbb/index.js'), 'bbb resolves');
+    });
+
+    resolve('ccc', {
+        paths: [
+            path.join(__dirname, '/node_path/x'),
+            path.join(__dirname, '/node_path/y')
+        ],
+        basedir: __dirname,
+        isDirectory: isDir
+    }, function (err, res) {
+        t.error(err);
+        t.equal(res, path.join(__dirname, '/node_path/x/ccc/index.js'), 'ccc resolves');
+    });
+
+    // ensure that relative paths still resolve against the regular `node_modules` correctly
+    resolve('tap', {
+        paths: [
+            'node_path'
+        ],
+        basedir: path.join(__dirname, 'node_path/x'),
+        isDirectory: isDir
+    }, function (err, res) {
+        var root = require('tap/package.json').main; // eslint-disable-line global-require
+        t.error(err);
+        t.equal(res, path.resolve(__dirname, '..', 'node_modules/tap', root), 'tap resolves');
+    });
+});
diff --git a/tools/ui/node_modules/resolve/test/node_path/x/aaa/index.js b/tools/ui/node_modules/resolve/test/node_path/x/aaa/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..ad70d0bb03f6f433224a681f9055fe9d0a388dfc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/node_path/x/aaa/index.js
@@ -0,0 +1 @@
+module.exports = 'A';
diff --git a/tools/ui/node_modules/resolve/test/node_path/x/ccc/index.js b/tools/ui/node_modules/resolve/test/node_path/x/ccc/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..a64132e4c7e52cfea76744d826e99932e994c7c1
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/node_path/x/ccc/index.js
@@ -0,0 +1 @@
+module.exports = 'C';
diff --git a/tools/ui/node_modules/resolve/test/node_path/y/bbb/index.js b/tools/ui/node_modules/resolve/test/node_path/y/bbb/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..4d0f32e24368185d6f3c16445f88b902329025d6
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/node_path/y/bbb/index.js
@@ -0,0 +1 @@
+module.exports = 'B';
diff --git a/tools/ui/node_modules/resolve/test/node_path/y/ccc/index.js b/tools/ui/node_modules/resolve/test/node_path/y/ccc/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..793315e846687e1dd2bae012fc30676b2a421753
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/node_path/y/ccc/index.js
@@ -0,0 +1 @@
+module.exports = 'CY';
diff --git a/tools/ui/node_modules/resolve/test/nonstring.js b/tools/ui/node_modules/resolve/test/nonstring.js
new file mode 100644
index 0000000000000000000000000000000000000000..ef63c40f9393dc63219d5e3debb7ed6db175c455
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/nonstring.js
@@ -0,0 +1,9 @@
+var test = require('tape');
+var resolve = require('../');
+
+test('nonstring', function (t) {
+    t.plan(1);
+    resolve(555, function (err, res, pkg) {
+        t.ok(err);
+    });
+});
diff --git a/tools/ui/node_modules/resolve/test/pathfilter.js b/tools/ui/node_modules/resolve/test/pathfilter.js
new file mode 100644
index 0000000000000000000000000000000000000000..02df3ffe8e8e29f8b567bacfaa1f6adaedebb1a1
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/pathfilter.js
@@ -0,0 +1,75 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+var resolverDir = path.join(__dirname, '/pathfilter/deep_ref');
+
+function pathFilterFactory(t) {
+    return function (pkg, x, remainder) {
+        t.equal(pkg.version, '1.2.3');
+        t.equal(x, path.join(resolverDir, 'node_modules/deep/ref'));
+        t.equal(remainder, 'ref');
+        return 'alt';
+    };
+}
+
+test('#62: deep module references and the pathFilter', function (t) {
+    t.test('deep/ref.js', function (st) {
+        st.plan(3);
+
+        resolve('deep/ref', { basedir: resolverDir }, function (err, res, pkg) {
+            if (err) st.fail(err);
+
+            st.equal(pkg.version, '1.2.3');
+            st.equal(res, path.join(resolverDir, 'node_modules/deep/ref.js'));
+        });
+
+        var res = resolve.sync('deep/ref', { basedir: resolverDir });
+        st.equal(res, path.join(resolverDir, 'node_modules/deep/ref.js'));
+    });
+
+    t.test('deep/deeper/ref', function (st) {
+        st.plan(4);
+
+        resolve(
+            'deep/deeper/ref',
+            { basedir: resolverDir },
+            function (err, res, pkg) {
+                if (err) t.fail(err);
+                st.notEqual(pkg, undefined);
+                st.equal(pkg.version, '1.2.3');
+                st.equal(res, path.join(resolverDir, 'node_modules/deep/deeper/ref.js'));
+            }
+        );
+
+        var res = resolve.sync(
+            'deep/deeper/ref',
+            { basedir: resolverDir }
+        );
+        st.equal(res, path.join(resolverDir, 'node_modules/deep/deeper/ref.js'));
+    });
+
+    t.test('deep/ref alt', function (st) {
+        st.plan(8);
+
+        var pathFilter = pathFilterFactory(st);
+
+        var res = resolve.sync(
+            'deep/ref',
+            { basedir: resolverDir, pathFilter: pathFilter }
+        );
+        st.equal(res, path.join(resolverDir, 'node_modules/deep/alt.js'));
+
+        resolve(
+            'deep/ref',
+            { basedir: resolverDir, pathFilter: pathFilter },
+            function (err, res, pkg) {
+                if (err) st.fail(err);
+                st.equal(res, path.join(resolverDir, 'node_modules/deep/alt.js'));
+                st.end();
+            }
+        );
+    });
+
+    t.end();
+});
diff --git a/tools/ui/node_modules/resolve/test/pathfilter/deep_ref/main.js b/tools/ui/node_modules/resolve/test/pathfilter/deep_ref/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/pathfilter_sync.js b/tools/ui/node_modules/resolve/test/pathfilter_sync.js
new file mode 100644
index 0000000000000000000000000000000000000000..b404d11dc6998e9f32feb2e205f4d4495da7fdf9
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/pathfilter_sync.js
@@ -0,0 +1,24 @@
+var test = require('tape');
+var path = require('path');
+var resolve = require('../');
+
+test('synchronous pathfilter', function (t) {
+    var res;
+    var resolverDir = __dirname + '/pathfilter/deep_ref';
+    function pathFilter(pkg, x, remainder) {
+        t.equal(pkg.version, '1.2.3');
+        t.equal(x, path.join(resolverDir, 'node_modules', 'deep', 'ref'));
+        t.equal(remainder, 'ref');
+        return 'alt';
+    }
+
+    res = resolve.sync('deep/ref', { basedir: resolverDir });
+    t.equal(res, path.join(resolverDir, 'node_modules', 'deep', 'ref.js'));
+
+    res = resolve.sync('deep/deeper/ref', { basedir: resolverDir });
+    t.equal(res, path.join(resolverDir, 'node_modules', 'deep', 'deeper', 'ref.js'));
+
+    res = resolve.sync('deep/ref', { basedir: resolverDir, pathFilter: pathFilter });
+    t.equal(res, path.join(resolverDir, 'node_modules', 'deep', 'alt.js'));
+    t.end();
+});
diff --git a/tools/ui/node_modules/resolve/test/precedence.js b/tools/ui/node_modules/resolve/test/precedence.js
new file mode 100644
index 0000000000000000000000000000000000000000..2febb598fbc06832ce5b076735cb9f79fb257c7c
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/precedence.js
@@ -0,0 +1,23 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('precedence', function (t) {
+    t.plan(3);
+    var dir = path.join(__dirname, 'precedence/aaa');
+
+    resolve('./', { basedir: dir }, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, 'index.js'));
+        t.equal(pkg.name, 'resolve');
+    });
+});
+
+test('./ should not load ${dir}.js', function (t) { // eslint-disable-line no-template-curly-in-string
+    t.plan(1);
+    var dir = path.join(__dirname, 'precedence/bbb');
+
+    resolve('./', { basedir: dir }, function (err, res, pkg) {
+        t.ok(err);
+    });
+});
diff --git a/tools/ui/node_modules/resolve/test/precedence/aaa.js b/tools/ui/node_modules/resolve/test/precedence/aaa.js
new file mode 100644
index 0000000000000000000000000000000000000000..b83a3e7ad98d17536ebc574326276c0fe341b99a
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/precedence/aaa.js
@@ -0,0 +1 @@
+module.exports = 'wtf';
diff --git a/tools/ui/node_modules/resolve/test/precedence/aaa/index.js b/tools/ui/node_modules/resolve/test/precedence/aaa/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..e0f8f6abf72f7fe517abf6c57fae219b831b1cc9
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/precedence/aaa/index.js
@@ -0,0 +1 @@
+module.exports = 'okok';
diff --git a/tools/ui/node_modules/resolve/test/precedence/aaa/main.js b/tools/ui/node_modules/resolve/test/precedence/aaa/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..93542a965e0ea4fa1a548dcb4491e1defd73afe0
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/precedence/aaa/main.js
@@ -0,0 +1 @@
+console.log(require('./'));
diff --git a/tools/ui/node_modules/resolve/test/precedence/bbb.js b/tools/ui/node_modules/resolve/test/precedence/bbb.js
new file mode 100644
index 0000000000000000000000000000000000000000..2298f47fdd16dcc8375b62d1a15109a5833da926
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/precedence/bbb.js
@@ -0,0 +1 @@
+module.exports = '>_<';
diff --git a/tools/ui/node_modules/resolve/test/precedence/bbb/main.js b/tools/ui/node_modules/resolve/test/precedence/bbb/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..716b81d4bd463f66980f3cb44588b283bfb23edc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/precedence/bbb/main.js
@@ -0,0 +1 @@
+console.log(require('./')); // should throw
diff --git a/tools/ui/node_modules/resolve/test/resolver.js b/tools/ui/node_modules/resolve/test/resolver.js
new file mode 100644
index 0000000000000000000000000000000000000000..220fd3b7147322827560f4896fc016b10308bc48
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver.js
@@ -0,0 +1,597 @@
+var path = require('path');
+var fs = require('fs');
+var test = require('tape');
+var resolve = require('../');
+var async = require('../async');
+
+test('`./async` entry point', function (t) {
+    t.equal(resolve, async, '`./async` entry point is the same as `main`');
+    t.end();
+});
+
+test('async foo', function (t) {
+    t.plan(12);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./foo', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+        t.equal(pkg && pkg.name, 'resolve');
+    });
+
+    resolve('./foo.js', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+        t.equal(pkg && pkg.name, 'resolve');
+    });
+
+    resolve('./foo', { basedir: dir, 'package': { main: 'resolver' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+        t.equal(pkg && pkg.main, 'resolver');
+    });
+
+    resolve('./foo.js', { basedir: dir, 'package': { main: 'resolver' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+        t.equal(pkg.main, 'resolver');
+    });
+
+    resolve('./foo', { basedir: dir, filename: path.join(dir, 'baz.js') }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+    });
+
+    resolve('foo', { basedir: dir }, function (err) {
+        t.equal(err.message, "Cannot find module 'foo' from '" + path.resolve(dir) + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    // Test that filename is reported as the "from" value when passed.
+    resolve('foo', { basedir: dir, filename: path.join(dir, 'baz.js') }, function (err) {
+        t.equal(err.message, "Cannot find module 'foo' from '" + path.join(dir, 'baz.js') + "'");
+    });
+});
+
+test('bar', function (t) {
+    t.plan(6);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('foo', { basedir: dir + '/bar' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'bar/node_modules/foo/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('foo', { basedir: dir + '/bar' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'bar/node_modules/foo/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('foo', { basedir: dir + '/bar', 'package': { main: 'bar' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'bar/node_modules/foo/index.js'));
+        t.equal(pkg.main, 'bar');
+    });
+});
+
+test('baz', function (t) {
+    t.plan(4);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./baz', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'baz/quux.js'));
+        t.equal(pkg.main, 'quux.js');
+    });
+
+    resolve('./baz', { basedir: dir, 'package': { main: 'resolver' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'baz/quux.js'));
+        t.equal(pkg.main, 'quux.js');
+    });
+});
+
+test('biz', function (t) {
+    t.plan(24);
+    var dir = path.join(__dirname, 'resolver/biz/node_modules');
+
+    resolve('./grux', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'grux/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('./grux', { basedir: dir, 'package': { main: 'biz' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'grux/index.js'));
+        t.equal(pkg.main, 'biz');
+    });
+
+    resolve('./garply', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'garply/lib/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+
+    resolve('./garply', { basedir: dir, 'package': { main: 'biz' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'garply/lib/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+
+    resolve('tiv', { basedir: dir + '/grux' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'tiv/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('tiv', { basedir: dir + '/grux', 'package': { main: 'grux' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'tiv/index.js'));
+        t.equal(pkg.main, 'grux');
+    });
+
+    resolve('tiv', { basedir: dir + '/garply' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'tiv/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('tiv', { basedir: dir + '/garply', 'package': { main: './lib' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'tiv/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+
+    resolve('grux', { basedir: dir + '/tiv' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'grux/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('grux', { basedir: dir + '/tiv', 'package': { main: 'tiv' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'grux/index.js'));
+        t.equal(pkg.main, 'tiv');
+    });
+
+    resolve('garply', { basedir: dir + '/tiv' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'garply/lib/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+
+    resolve('garply', { basedir: dir + '/tiv', 'package': { main: 'tiv' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'garply/lib/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+});
+
+test('quux', function (t) {
+    t.plan(2);
+    var dir = path.join(__dirname, 'resolver/quux');
+
+    resolve('./foo', { basedir: dir, 'package': { main: 'quux' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo/index.js'));
+        t.equal(pkg.main, 'quux');
+    });
+});
+
+test('normalize', function (t) {
+    t.plan(2);
+    var dir = path.join(__dirname, 'resolver/biz/node_modules/grux');
+
+    resolve('../grux', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'index.js'));
+        t.equal(pkg, undefined);
+    });
+});
+
+test('cup', function (t) {
+    t.plan(5);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./cup', { basedir: dir, extensions: ['.js', '.coffee'] }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'cup.coffee'));
+    });
+
+    resolve('./cup.coffee', { basedir: dir }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'cup.coffee'));
+    });
+
+    resolve('./cup', { basedir: dir, extensions: ['.js'] }, function (err, res) {
+        t.equal(err.message, "Cannot find module './cup' from '" + path.resolve(dir) + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    // Test that filename is reported as the "from" value when passed.
+    resolve('./cup', { basedir: dir, extensions: ['.js'], filename: path.join(dir, 'cupboard.js') }, function (err, res) {
+        t.equal(err.message, "Cannot find module './cup' from '" + path.join(dir, 'cupboard.js') + "'");
+    });
+});
+
+test('mug', function (t) {
+    t.plan(3);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./mug', { basedir: dir }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'mug.js'));
+    });
+
+    resolve('./mug', { basedir: dir, extensions: ['.coffee', '.js'] }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, '/mug.coffee'));
+    });
+
+    resolve('./mug', { basedir: dir, extensions: ['.js', '.coffee'] }, function (err, res) {
+        t.equal(res, path.join(dir, '/mug.js'));
+    });
+});
+
+test('other path', function (t) {
+    t.plan(6);
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'bar');
+    var otherDir = path.join(resolverDir, 'other_path');
+
+    resolve('root', { basedir: dir, paths: [otherDir] }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(resolverDir, 'other_path/root.js'));
+    });
+
+    resolve('lib/other-lib', { basedir: dir, paths: [otherDir] }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(resolverDir, 'other_path/lib/other-lib.js'));
+    });
+
+    resolve('root', { basedir: dir }, function (err, res) {
+        t.equal(err.message, "Cannot find module 'root' from '" + path.resolve(dir) + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    resolve('zzz', { basedir: dir, paths: [otherDir] }, function (err, res) {
+        t.equal(err.message, "Cannot find module 'zzz' from '" + path.resolve(dir) + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+});
+
+test('path iterator', function (t) {
+    t.plan(2);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    function exactIterator(x, start, getPackageCandidates, opts) {
+        return [path.join(resolverDir, x)];
+    }
+
+    resolve('baz', { packageIterator: exactIterator }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(resolverDir, 'baz/quux.js'));
+        t.equal(pkg && pkg.name, 'baz');
+    });
+});
+
+test('incorrect main', function (t) {
+    t.plan(1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'incorrect_main');
+
+    resolve('./incorrect_main', { basedir: resolverDir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'index.js'));
+    });
+});
+
+test('missing index', function (t) {
+    t.plan(2);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+    resolve('./missing_index', { basedir: resolverDir }, function (err, res, pkg) {
+        t.ok(err instanceof Error);
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    });
+});
+
+test('missing main', function (t) {
+    t.plan(1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    resolve('./missing_main', { basedir: resolverDir }, function (err, res, pkg) {
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    });
+});
+
+test('null main', function (t) {
+    t.plan(1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    resolve('./null_main', { basedir: resolverDir }, function (err, res, pkg) {
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    });
+});
+
+test('main: false', function (t) {
+    t.plan(2);
+
+    var basedir = path.join(__dirname, 'resolver');
+    var dir = path.join(basedir, 'false_main');
+    resolve('./false_main', { basedir: basedir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(
+            res,
+            path.join(dir, 'index.js'),
+            '`"main": false`: resolves to `index.js`'
+        );
+        t.deepEqual(pkg, {
+            name: 'false_main',
+            main: false
+        });
+    });
+});
+
+test('without basedir', function (t) {
+    t.plan(1);
+
+    var dir = path.join(__dirname, 'resolver/without_basedir');
+    var tester = require(path.join(dir, 'main.js')); // eslint-disable-line global-require
+
+    tester(t, function (err, res, pkg) {
+        if (err) {
+            t.fail(err);
+        } else {
+            t.equal(res, path.join(dir, 'node_modules/mymodule.js'));
+        }
+    });
+});
+
+test('#52 - incorrectly resolves module-paths like "./someFolder/" when there is a file of the same name', function (t) {
+    t.plan(2);
+
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./foo', { basedir: path.join(dir, 'same_names') }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'same_names/foo.js'));
+    });
+
+    resolve('./foo/', { basedir: path.join(dir, 'same_names') }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'same_names/foo/index.js'));
+    });
+});
+
+test('#211 - incorrectly resolves module-paths like "." when from inside a folder with a sibling file of the same name', function (t) {
+    t.plan(2);
+
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./', { basedir: path.join(dir, 'same_names/foo') }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'same_names/foo/index.js'));
+    });
+
+    resolve('.', { basedir: path.join(dir, 'same_names/foo') }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'same_names/foo/index.js'));
+    });
+});
+
+test('async: #121 - treating an existing file as a dir when no basedir', function (t) {
+    var testFile = path.basename(__filename);
+
+    t.test('sanity check', function (st) {
+        st.plan(1);
+        resolve('./' + testFile, function (err, res, pkg) {
+            if (err) t.fail(err);
+            st.equal(res, __filename, 'sanity check');
+        });
+    });
+
+    t.test('with a fake directory', function (st) {
+        st.plan(4);
+
+        resolve('./' + testFile + '/blah', function (err, res, pkg) {
+            st.ok(err, 'there is an error');
+            st.notOk(res, 'no result');
+
+            st.equal(err && err.code, 'MODULE_NOT_FOUND', 'error code matches require.resolve');
+            st.equal(
+                err && err.message,
+                'Cannot find module \'./' + testFile + '/blah\' from \'' + __dirname + '\'',
+                'can not find nonexistent module'
+            );
+            st.end();
+        });
+    });
+
+    t.end();
+});
+
+test('async dot main', function (t) {
+    var start = new Date();
+    t.plan(3);
+    resolve('./resolver/dot_main', function (err, ret) {
+        t.notOk(err);
+        t.equal(ret, path.join(__dirname, 'resolver/dot_main/index.js'));
+        t.ok(new Date() - start < 50, 'resolve.sync timedout');
+        t.end();
+    });
+});
+
+test('async dot slash main', function (t) {
+    var start = new Date();
+    t.plan(3);
+    resolve('./resolver/dot_slash_main', function (err, ret) {
+        t.notOk(err);
+        t.equal(ret, path.join(__dirname, 'resolver/dot_slash_main/index.js'));
+        t.ok(new Date() - start < 50, 'resolve.sync timedout');
+        t.end();
+    });
+});
+
+test('not a directory', function (t) {
+    t.plan(6);
+    var path = './foo';
+    resolve(path, { basedir: __filename }, function (err, res, pkg) {
+        t.ok(err, 'a non-directory errors');
+        t.equal(arguments.length, 1);
+        t.equal(res, undefined);
+        t.equal(pkg, undefined);
+
+        t.equal(err && err.message, 'Cannot find module \'' + path + '\' from \'' + __filename + '\'');
+        t.equal(err && err.code, 'MODULE_NOT_FOUND');
+    });
+});
+
+test('non-string "main" field in package.json', function (t) {
+    t.plan(5);
+
+    var dir = path.join(__dirname, 'resolver');
+    resolve('./invalid_main', { basedir: dir }, function (err, res, pkg) {
+        t.ok(err, 'errors on non-string main');
+        t.equal(err.message, 'package “invalid_main” `main` must be a string');
+        t.equal(err.code, 'INVALID_PACKAGE_MAIN');
+        t.equal(res, undefined, 'res is undefined');
+        t.equal(pkg, undefined, 'pkg is undefined');
+    });
+});
+
+test('non-string "main" field in package.json', function (t) {
+    t.plan(5);
+
+    var dir = path.join(__dirname, 'resolver');
+    resolve('./invalid_main', { basedir: dir }, function (err, res, pkg) {
+        t.ok(err, 'errors on non-string main');
+        t.equal(err.message, 'package “invalid_main” `main` must be a string');
+        t.equal(err.code, 'INVALID_PACKAGE_MAIN');
+        t.equal(res, undefined, 'res is undefined');
+        t.equal(pkg, undefined, 'pkg is undefined');
+    });
+});
+
+test('browser field in package.json', function (t) {
+    t.plan(3);
+
+    var dir = path.join(__dirname, 'resolver');
+    resolve(
+        './browser_field',
+        {
+            basedir: dir,
+            packageFilter: function packageFilter(pkg) {
+                if (pkg.browser) {
+                    pkg.main = pkg.browser; // eslint-disable-line no-param-reassign
+                    delete pkg.browser; // eslint-disable-line no-param-reassign
+                }
+                return pkg;
+            }
+        },
+        function (err, res, pkg) {
+            if (err) t.fail(err);
+            t.equal(res, path.join(dir, 'browser_field', 'b.js'));
+            t.equal(pkg && pkg.main, 'b');
+            t.equal(pkg && pkg.browser, undefined);
+        }
+    );
+});
+
+test('absolute paths', function (t) {
+    t.plan(4);
+
+    var extensionless = __filename.slice(0, -path.extname(__filename).length);
+
+    resolve(__filename, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'absolute path to this file resolves'
+        );
+    });
+    resolve(extensionless, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'extensionless absolute path to this file resolves'
+        );
+    });
+    resolve(__filename, { basedir: process.cwd() }, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'absolute path to this file with a basedir resolves'
+        );
+    });
+    resolve(extensionless, { basedir: process.cwd() }, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'extensionless absolute path to this file with a basedir resolves'
+        );
+    });
+});
+
+var malformedDir = path.join(__dirname, 'resolver/malformed_package_json');
+test('malformed package.json', { skip: !fs.existsSync(malformedDir) }, function (t) {
+    /* eslint operator-linebreak: ["error", "before"], function-paren-newline: "off" */
+    t.plan(
+        (3 * 3) // 3 sets of 3 assertions in the final callback
+        + 2 // 1 readPackage call with malformed package.json
+    );
+
+    var basedir = malformedDir;
+    var expected = path.join(basedir, 'index.js');
+
+    resolve('./index.js', { basedir: basedir }, function (err, res, pkg) {
+        t.error(err, 'no error');
+        t.equal(res, expected, 'malformed package.json is silently ignored');
+        t.equal(pkg, undefined, 'malformed package.json gives an undefined `pkg` argument');
+    });
+
+    resolve(
+        './index.js',
+        {
+            basedir: basedir,
+            packageFilter: function (pkg, pkgfile, dir) {
+                t.fail('should not reach here');
+            }
+        },
+        function (err, res, pkg) {
+            t.error(err, 'with packageFilter: no error');
+            t.equal(res, expected, 'with packageFilter: malformed package.json is silently ignored');
+            t.equal(pkg, undefined, 'with packageFilter: malformed package.json gives an undefined `pkg` argument');
+        }
+    );
+
+    resolve(
+        './index.js',
+        {
+            basedir: basedir,
+            readPackage: function (readFile, pkgfile, cb) {
+                t.equal(pkgfile, path.join(basedir, 'package.json'), 'readPackageSync: `pkgfile` is package.json path');
+                readFile(pkgfile, function (err, result) {
+                    try {
+                        cb(null, JSON.parse(result));
+                    } catch (e) {
+                        t.ok(e instanceof SyntaxError, 'readPackage: malformed package.json parses as a syntax error');
+                        cb(null);
+                    }
+                });
+            }
+        },
+        function (err, res, pkg) {
+            t.error(err, 'with readPackage: no error');
+            t.equal(res, expected, 'with readPackage: malformed package.json is silently ignored');
+            t.equal(pkg, undefined, 'with readPackage: malformed package.json gives an undefined `pkg` argument');
+        }
+    );
+});
diff --git a/tools/ui/node_modules/resolve/test/resolver/baz/doom.js b/tools/ui/node_modules/resolve/test/resolver/baz/doom.js
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/resolver/baz/package.json b/tools/ui/node_modules/resolve/test/resolver/baz/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..2f77720b8672a0e2ed8b49636775335884cb3ec0
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/baz/package.json
@@ -0,0 +1,4 @@
+{
+    "name": "baz",
+    "main": "quux.js"
+}
diff --git a/tools/ui/node_modules/resolve/test/resolver/baz/quux.js b/tools/ui/node_modules/resolve/test/resolver/baz/quux.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd816eaba4ca3be8e4d68cfc0ae9f64b5aa712cc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/baz/quux.js
@@ -0,0 +1 @@
+module.exports = 1;
diff --git a/tools/ui/node_modules/resolve/test/resolver/browser_field/a.js b/tools/ui/node_modules/resolve/test/resolver/browser_field/a.js
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/resolver/browser_field/b.js b/tools/ui/node_modules/resolve/test/resolver/browser_field/b.js
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/resolver/browser_field/package.json b/tools/ui/node_modules/resolve/test/resolver/browser_field/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..bf406f0830f8aab6aaec9e3f60f1623fbe6854e6
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/browser_field/package.json
@@ -0,0 +1,5 @@
+{
+  "name": "browser_field",
+  "main": "a",
+  "browser": "b"
+}
diff --git a/tools/ui/node_modules/resolve/test/resolver/cup.coffee b/tools/ui/node_modules/resolve/test/resolver/cup.coffee
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/cup.coffee
@@ -0,0 +1 @@
+
diff --git a/tools/ui/node_modules/resolve/test/resolver/dot_main/index.js b/tools/ui/node_modules/resolve/test/resolver/dot_main/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd816eaba4ca3be8e4d68cfc0ae9f64b5aa712cc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/dot_main/index.js
@@ -0,0 +1 @@
+module.exports = 1;
diff --git a/tools/ui/node_modules/resolve/test/resolver/dot_main/package.json b/tools/ui/node_modules/resolve/test/resolver/dot_main/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..d7f4fc8079f60aaee820b293537b21d488a1bc31
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/dot_main/package.json
@@ -0,0 +1,3 @@
+{
+    "main": "."
+}
diff --git a/tools/ui/node_modules/resolve/test/resolver/dot_slash_main/index.js b/tools/ui/node_modules/resolve/test/resolver/dot_slash_main/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd816eaba4ca3be8e4d68cfc0ae9f64b5aa712cc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/dot_slash_main/index.js
@@ -0,0 +1 @@
+module.exports = 1;
diff --git a/tools/ui/node_modules/resolve/test/resolver/dot_slash_main/package.json b/tools/ui/node_modules/resolve/test/resolver/dot_slash_main/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..f51287b9d1e739a8827578a541e89f7e91450615
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/dot_slash_main/package.json
@@ -0,0 +1,3 @@
+{
+    "main": "./"
+}
diff --git a/tools/ui/node_modules/resolve/test/resolver/false_main/index.js b/tools/ui/node_modules/resolve/test/resolver/false_main/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/resolver/false_main/package.json b/tools/ui/node_modules/resolve/test/resolver/false_main/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..a7416c0c7aa4a1df56419f92dcc7519836db8978
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/false_main/package.json
@@ -0,0 +1,4 @@
+{
+	"name": "false_main",
+	"main": false
+}
diff --git a/tools/ui/node_modules/resolve/test/resolver/foo.js b/tools/ui/node_modules/resolve/test/resolver/foo.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd816eaba4ca3be8e4d68cfc0ae9f64b5aa712cc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/foo.js
@@ -0,0 +1 @@
+module.exports = 1;
diff --git a/tools/ui/node_modules/resolve/test/resolver/incorrect_main/index.js b/tools/ui/node_modules/resolve/test/resolver/incorrect_main/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..bc1fb0a6f4ede17ec05e767ca8ccacbc3015ff70
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/incorrect_main/index.js
@@ -0,0 +1,2 @@
+// this is the actual main file 'index.js', not 'wrong.js' like the package.json would indicate
+module.exports = 1;
diff --git a/tools/ui/node_modules/resolve/test/resolver/incorrect_main/package.json b/tools/ui/node_modules/resolve/test/resolver/incorrect_main/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..b7188041763f8a94977f173a26c41fdbf5f2effb
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/incorrect_main/package.json
@@ -0,0 +1,3 @@
+{
+    "main": "wrong.js"
+}
diff --git a/tools/ui/node_modules/resolve/test/resolver/invalid_main/package.json b/tools/ui/node_modules/resolve/test/resolver/invalid_main/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..0590748642ae2eadb17726ec3d1b501c94652277
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/invalid_main/package.json
@@ -0,0 +1,7 @@
+{
+  "name": "invalid_main",
+  "main": [
+    "why is this a thing",
+    "srsly omg wtf"
+  ]
+}
diff --git a/tools/ui/node_modules/resolve/test/resolver/mug.coffee b/tools/ui/node_modules/resolve/test/resolver/mug.coffee
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/resolver/mug.js b/tools/ui/node_modules/resolve/test/resolver/mug.js
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/resolver/multirepo/lerna.json b/tools/ui/node_modules/resolve/test/resolver/multirepo/lerna.json
new file mode 100644
index 0000000000000000000000000000000000000000..d6707ca0cd64d48d212b90abe2e72f24b092572f
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/multirepo/lerna.json
@@ -0,0 +1,6 @@
+{
+  "packages": [
+    "packages/*"
+  ],
+  "version": "0.0.0"
+}
diff --git a/tools/ui/node_modules/resolve/test/resolver/multirepo/package.json b/tools/ui/node_modules/resolve/test/resolver/multirepo/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..4391d392ea2761caea4d8286cc8ccc56cfa3e4a5
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/multirepo/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "ljharb-monorepo-symlink-test",
+  "private": true,
+  "version": "0.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "postinstall": "lerna bootstrap",
+    "test": "node packages/package-a"
+  },
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "jquery": "^3.3.1",
+    "resolve": "../../../"
+  },
+  "devDependencies": {
+    "lerna": "^3.4.3"
+  }
+}
diff --git a/tools/ui/node_modules/resolve/test/resolver/multirepo/packages/package-a/index.js b/tools/ui/node_modules/resolve/test/resolver/multirepo/packages/package-a/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..8875a32df0ffc4eda94bb6c6dd9855ac604820c4
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/multirepo/packages/package-a/index.js
@@ -0,0 +1,35 @@
+'use strict';
+
+var assert = require('assert');
+var path = require('path');
+var resolve = require('resolve');
+
+var basedir = __dirname + '/node_modules/@my-scope/package-b';
+
+var expected = path.join(__dirname, '../../node_modules/jquery/dist/jquery.js');
+
+/*
+ * preserveSymlinks === false
+ * will search NPM package from
+ * - packages/package-b/node_modules
+ * - packages/node_modules
+ * - node_modules
+ */
+assert.equal(resolve.sync('jquery', { basedir: basedir, preserveSymlinks: false }), expected);
+assert.equal(resolve.sync('../../node_modules/jquery', { basedir: basedir, preserveSymlinks: false }), expected);
+
+/*
+ * preserveSymlinks === true
+ * will search NPM package from
+ * - packages/package-a/node_modules/@my-scope/packages/package-b/node_modules
+ * - packages/package-a/node_modules/@my-scope/packages/node_modules
+ * - packages/package-a/node_modules/@my-scope/node_modules
+ * - packages/package-a/node_modules/node_modules
+ * - packages/package-a/node_modules
+ * - packages/node_modules
+ * - node_modules
+ */
+assert.equal(resolve.sync('jquery', { basedir: basedir, preserveSymlinks: true }), expected);
+assert.equal(resolve.sync('../../../../../node_modules/jquery', { basedir: basedir, preserveSymlinks: true }), expected);
+
+console.log(' * all monorepo paths successfully resolved through symlinks');
diff --git a/tools/ui/node_modules/resolve/test/resolver/multirepo/packages/package-a/package.json b/tools/ui/node_modules/resolve/test/resolver/multirepo/packages/package-a/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..204de51e05878b3451223ba654c5e4a790ef1e51
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/multirepo/packages/package-a/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "@my-scope/package-a",
+  "version": "0.0.0",
+  "private": true,
+  "description": "",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "dependencies": {
+    "@my-scope/package-b": "^0.0.0"
+  }
+}
diff --git a/tools/ui/node_modules/resolve/test/resolver/multirepo/packages/package-b/index.js b/tools/ui/node_modules/resolve/test/resolver/multirepo/packages/package-b/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/resolver/multirepo/packages/package-b/package.json b/tools/ui/node_modules/resolve/test/resolver/multirepo/packages/package-b/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..f57c3b5f5e454d3948e1a4bc5aec10fdcd79d8b5
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/multirepo/packages/package-b/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "@my-scope/package-b",
+  "private": true,
+  "version": "0.0.0",
+  "description": "",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "dependencies": {
+    "@my-scope/package-a": "^0.0.0"
+  }
+}
diff --git a/tools/ui/node_modules/resolve/test/resolver/nested_symlinks/mylib/async.js b/tools/ui/node_modules/resolve/test/resolver/nested_symlinks/mylib/async.js
new file mode 100644
index 0000000000000000000000000000000000000000..fc2ef242be5eb7a4af7f514e01f916e321717601
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/nested_symlinks/mylib/async.js
@@ -0,0 +1,26 @@
+var a = require.resolve('buffer/').replace(process.cwd(), '$CWD');
+var b;
+var c;
+
+function test() {
+    console.log(a, ': require.resolve, preserveSymlinks ' + (process.execArgv.indexOf('preserve-symlinks') > -1 ? 'true' : 'false'));
+    console.log(b, ': preserveSymlinks true');
+    console.log(c, ': preserveSymlinks false');
+
+    if (a !== b && a !== c) {
+        throw 'async: no match';
+    }
+    console.log('async: success! a matched either b or c\n');
+}
+
+require('resolve')('buffer/', { preserveSymlinks: true }, function (err, result) {
+    if (err) { throw err; }
+    b = result.replace(process.cwd(), '$CWD');
+    if (b && c) { test(); }
+});
+require('resolve')('buffer/', { preserveSymlinks: false }, function (err, result) {
+    if (err) { throw err; }
+    c = result.replace(process.cwd(), '$CWD');
+    if (b && c) { test(); }
+});
+
diff --git a/tools/ui/node_modules/resolve/test/resolver/nested_symlinks/mylib/package.json b/tools/ui/node_modules/resolve/test/resolver/nested_symlinks/mylib/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..acfe9e9517720ab5532c247052fadb214c5ffef3
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/nested_symlinks/mylib/package.json
@@ -0,0 +1,15 @@
+{
+  "name": "mylib",
+  "version": "0.0.0",
+  "description": "",
+  "private": true,
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "buffer": "*"
+  }
+}
diff --git a/tools/ui/node_modules/resolve/test/resolver/nested_symlinks/mylib/sync.js b/tools/ui/node_modules/resolve/test/resolver/nested_symlinks/mylib/sync.js
new file mode 100644
index 0000000000000000000000000000000000000000..3283efc2ec81f8d2a62be9a1fd28a192403ce549
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/nested_symlinks/mylib/sync.js
@@ -0,0 +1,12 @@
+var a = require.resolve('buffer/').replace(process.cwd(), '$CWD');
+var b = require('resolve').sync('buffer/', { preserveSymlinks: true }).replace(process.cwd(), '$CWD');
+var c = require('resolve').sync('buffer/', { preserveSymlinks: false }).replace(process.cwd(), '$CWD');
+
+console.log(a, ': require.resolve, preserveSymlinks ' + (process.execArgv.indexOf('preserve-symlinks') > -1 ? 'true' : 'false'));
+console.log(b, ': preserveSymlinks true');
+console.log(c, ': preserveSymlinks false');
+
+if (a !== b && a !== c) {
+    throw 'sync: no match';
+}
+console.log('sync: success! a matched either b or c\n');
diff --git a/tools/ui/node_modules/resolve/test/resolver/other_path/lib/other-lib.js b/tools/ui/node_modules/resolve/test/resolver/other_path/lib/other-lib.js
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/resolver/other_path/root.js b/tools/ui/node_modules/resolve/test/resolver/other_path/root.js
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/resolver/quux/foo/index.js b/tools/ui/node_modules/resolve/test/resolver/quux/foo/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd816eaba4ca3be8e4d68cfc0ae9f64b5aa712cc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/quux/foo/index.js
@@ -0,0 +1 @@
+module.exports = 1;
diff --git a/tools/ui/node_modules/resolve/test/resolver/same_names/foo.js b/tools/ui/node_modules/resolve/test/resolver/same_names/foo.js
new file mode 100644
index 0000000000000000000000000000000000000000..888cae37af95c51299d735439cf896dc4d5aaafc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/same_names/foo.js
@@ -0,0 +1 @@
+module.exports = 42;
diff --git a/tools/ui/node_modules/resolve/test/resolver/same_names/foo/index.js b/tools/ui/node_modules/resolve/test/resolver/same_names/foo/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd816eaba4ca3be8e4d68cfc0ae9f64b5aa712cc
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/same_names/foo/index.js
@@ -0,0 +1 @@
+module.exports = 1;
diff --git a/tools/ui/node_modules/resolve/test/resolver/symlinked/_/node_modules/foo.js b/tools/ui/node_modules/resolve/test/resolver/symlinked/_/node_modules/foo.js
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/resolver/symlinked/_/symlink_target/.gitkeep b/tools/ui/node_modules/resolve/test/resolver/symlinked/_/symlink_target/.gitkeep
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/resolver/symlinked/package/bar.js b/tools/ui/node_modules/resolve/test/resolver/symlinked/package/bar.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb1c2c01e753b31f6e550e991a82022f7acf8638
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/symlinked/package/bar.js
@@ -0,0 +1 @@
+module.exports = 'bar';
diff --git a/tools/ui/node_modules/resolve/test/resolver/symlinked/package/package.json b/tools/ui/node_modules/resolve/test/resolver/symlinked/package/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..8e1b585914a7b46cd21d5d8709ac08bc1fe84962
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/symlinked/package/package.json
@@ -0,0 +1,3 @@
+{
+    "main": "bar.js"
+}
\ No newline at end of file
diff --git a/tools/ui/node_modules/resolve/test/resolver/without_basedir/main.js b/tools/ui/node_modules/resolve/test/resolver/without_basedir/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..5b31975be69da5efea03fac676afa5f2199831be
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver/without_basedir/main.js
@@ -0,0 +1,5 @@
+var resolve = require('../../../');
+
+module.exports = function (t, cb) {
+    resolve('mymodule', null, cb);
+};
diff --git a/tools/ui/node_modules/resolve/test/resolver_sync.js b/tools/ui/node_modules/resolve/test/resolver_sync.js
new file mode 100644
index 0000000000000000000000000000000000000000..2f5ed43f010eb02d169fdbaf6456f15dcb36279f
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/resolver_sync.js
@@ -0,0 +1,730 @@
+var path = require('path');
+var fs = require('fs');
+var test = require('tape');
+
+var resolve = require('../');
+var sync = require('../sync');
+
+var requireResolveSupportsPaths = require.resolve.length > 1
+    && !(/^v12\.[012]\./).test(process.version); // broken in v12.0-12.2, see https://github.com/nodejs/node/issues/27794
+
+var requireResolveDefaultPathsBroken = (/^v8\.9\.|^v9\.[01]\.0|^v9\.2\./).test(process.version);
+// broken in node v8.9.x, v9.0, v9.1, v9.2.x. see https://github.com/nodejs/node/pull/17113
+
+test('`./sync` entry point', function (t) {
+    t.equal(resolve.sync, sync, '`./sync` entry point is the same as `.sync` on `main`');
+    t.end();
+});
+
+test('foo', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+
+    t.equal(
+        resolve.sync('./foo', { basedir: dir }),
+        path.join(dir, 'foo.js'),
+        './foo'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./foo', { basedir: dir }),
+            require.resolve('./foo', { paths: [dir] }),
+            './foo: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync('./foo.js', { basedir: dir }),
+        path.join(dir, 'foo.js'),
+        './foo.js'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./foo.js', { basedir: dir }),
+            require.resolve('./foo.js', { paths: [dir] }),
+            './foo.js: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync('./foo.js', { basedir: dir, filename: path.join(dir, 'bar.js') }),
+        path.join(dir, 'foo.js')
+    );
+
+    t.throws(function () {
+        resolve.sync('foo', { basedir: dir });
+    });
+
+    // Test that filename is reported as the "from" value when passed.
+    t.throws(
+        function () {
+            resolve.sync('foo', { basedir: dir, filename: path.join(dir, 'bar.js') });
+        },
+        {
+            name: 'Error',
+            message: "Cannot find module 'foo' from '" + path.join(dir, 'bar.js') + "'"
+        }
+    );
+
+    t.end();
+});
+
+test('bar', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+
+    var basedir = path.join(dir, 'bar');
+
+    t.equal(
+        resolve.sync('foo', { basedir: basedir }),
+        path.join(dir, 'bar/node_modules/foo/index.js'),
+        'foo in bar'
+    );
+    if (!requireResolveDefaultPathsBroken && requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('foo', { basedir: basedir }),
+            require.resolve('foo', { paths: [basedir] }),
+            'foo in bar: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('baz', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+
+    t.equal(
+        resolve.sync('./baz', { basedir: dir }),
+        path.join(dir, 'baz/quux.js'),
+        './baz'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./baz', { basedir: dir }),
+            require.resolve('./baz', { paths: [dir] }),
+            './baz: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('biz', function (t) {
+    var dir = path.join(__dirname, 'resolver/biz/node_modules');
+
+    t.equal(
+        resolve.sync('./grux', { basedir: dir }),
+        path.join(dir, 'grux/index.js')
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./grux', { basedir: dir }),
+            require.resolve('./grux', { paths: [dir] }),
+            './grux: resolve.sync === require.resolve'
+        );
+    }
+
+    var tivDir = path.join(dir, 'grux');
+    t.equal(
+        resolve.sync('tiv', { basedir: tivDir }),
+        path.join(dir, 'tiv/index.js')
+    );
+    if (!requireResolveDefaultPathsBroken && requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('tiv', { basedir: tivDir }),
+            require.resolve('tiv', { paths: [tivDir] }),
+            'tiv: resolve.sync === require.resolve'
+        );
+    }
+
+    var gruxDir = path.join(dir, 'tiv');
+    t.equal(
+        resolve.sync('grux', { basedir: gruxDir }),
+        path.join(dir, 'grux/index.js')
+    );
+    if (!requireResolveDefaultPathsBroken && requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('grux', { basedir: gruxDir }),
+            require.resolve('grux', { paths: [gruxDir] }),
+            'grux: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('normalize', function (t) {
+    var dir = path.join(__dirname, 'resolver/biz/node_modules/grux');
+
+    t.equal(
+        resolve.sync('../grux', { basedir: dir }),
+        path.join(dir, 'index.js')
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('../grux', { basedir: dir }),
+            require.resolve('../grux', { paths: [dir] }),
+            '../grux: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('cup', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+
+    t.equal(
+        resolve.sync('./cup', {
+            basedir: dir,
+            extensions: ['.js', '.coffee']
+        }),
+        path.join(dir, 'cup.coffee'),
+        './cup -> ./cup.coffee'
+    );
+
+    t.equal(
+        resolve.sync('./cup.coffee', { basedir: dir }),
+        path.join(dir, 'cup.coffee'),
+        './cup.coffee'
+    );
+
+    t.throws(function () {
+        resolve.sync('./cup', {
+            basedir: dir,
+            extensions: ['.js']
+        });
+    });
+
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./cup.coffee', { basedir: dir, extensions: ['.js', '.coffee'] }),
+            require.resolve('./cup.coffee', { paths: [dir] }),
+            './cup.coffee: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('mug', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+
+    t.equal(
+        resolve.sync('./mug', { basedir: dir }),
+        path.join(dir, 'mug.js'),
+        './mug -> ./mug.js'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./mug', { basedir: dir }),
+            require.resolve('./mug', { paths: [dir] }),
+            './mug: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync('./mug', {
+            basedir: dir,
+            extensions: ['.coffee', '.js']
+        }),
+        path.join(dir, 'mug.coffee'),
+        './mug -> ./mug.coffee'
+    );
+
+    t.equal(
+        resolve.sync('./mug', {
+            basedir: dir,
+            extensions: ['.js', '.coffee']
+        }),
+        path.join(dir, 'mug.js'),
+        './mug -> ./mug.js'
+    );
+
+    t.end();
+});
+
+test('other path', function (t) {
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'bar');
+    var otherDir = path.join(resolverDir, 'other_path');
+
+    t.equal(
+        resolve.sync('root', {
+            basedir: dir,
+            paths: [otherDir]
+        }),
+        path.join(resolverDir, 'other_path/root.js')
+    );
+
+    t.equal(
+        resolve.sync('lib/other-lib', {
+            basedir: dir,
+            paths: [otherDir]
+        }),
+        path.join(resolverDir, 'other_path/lib/other-lib.js')
+    );
+
+    t.throws(function () {
+        resolve.sync('root', { basedir: dir });
+    });
+
+    t.throws(function () {
+        resolve.sync('zzz', {
+            basedir: dir,
+            paths: [otherDir]
+        });
+    });
+
+    t.end();
+});
+
+test('path iterator', function (t) {
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    function exactIterator(x, start, getPackageCandidates, opts) {
+        return [path.join(resolverDir, x)];
+    }
+
+    t.equal(
+        resolve.sync('baz', { packageIterator: exactIterator }),
+        path.join(resolverDir, 'baz/quux.js')
+    );
+
+    t.end();
+});
+
+test('incorrect main', function (t) {
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'incorrect_main');
+
+    t.equal(
+        resolve.sync('./incorrect_main', { basedir: resolverDir }),
+        path.join(dir, 'index.js')
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./incorrect_main', { basedir: resolverDir }),
+            require.resolve('./incorrect_main', { paths: [resolverDir] }),
+            './incorrect_main: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('missing index', function (t) {
+    t.plan(requireResolveSupportsPaths ? 2 : 1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+    try {
+        resolve.sync('./missing_index', { basedir: resolverDir });
+        t.fail('did not fail');
+    } catch (err) {
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    }
+    if (requireResolveSupportsPaths) {
+        try {
+            require.resolve('./missing_index', { basedir: resolverDir });
+            t.fail('require.resolve did not fail');
+        } catch (err) {
+            t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+        }
+    }
+});
+
+test('missing main', function (t) {
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    try {
+        resolve.sync('./missing_main', { basedir: resolverDir });
+        t.fail('require.resolve did not fail');
+    } catch (err) {
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    }
+    if (requireResolveSupportsPaths) {
+        try {
+            resolve.sync('./missing_main', { basedir: resolverDir });
+            t.fail('require.resolve did not fail');
+        } catch (err) {
+            t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+        }
+    }
+
+    t.end();
+});
+
+test('null main', function (t) {
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    try {
+        resolve.sync('./null_main', { basedir: resolverDir });
+        t.fail('require.resolve did not fail');
+    } catch (err) {
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    }
+    if (requireResolveSupportsPaths) {
+        try {
+            resolve.sync('./null_main', { basedir: resolverDir });
+            t.fail('require.resolve did not fail');
+        } catch (err) {
+            t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+        }
+    }
+
+    t.end();
+});
+
+test('main: false', function (t) {
+    var basedir = path.join(__dirname, 'resolver');
+    var dir = path.join(basedir, 'false_main');
+    t.equal(
+        resolve.sync('./false_main', { basedir: basedir }),
+        path.join(dir, 'index.js'),
+        '`"main": false`: resolves to `index.js`'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./false_main', { basedir: basedir }),
+            require.resolve('./false_main', { paths: [basedir] }),
+            '`"main": false`: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+function stubStatSync(fn) {
+    var statSync = fs.statSync;
+    try {
+        fs.statSync = function () {
+            throw new EvalError('Unknown Error');
+        };
+        return fn();
+    } finally {
+        fs.statSync = statSync;
+    }
+}
+
+test('#79 - re-throw non ENOENT errors from stat', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+
+    stubStatSync(function () {
+        t.throws(function () {
+            resolve.sync('foo', { basedir: dir });
+        }, /Unknown Error/);
+    });
+
+    t.end();
+});
+
+test('#52 - incorrectly resolves module-paths like "./someFolder/" when there is a file of the same name', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    var basedir = path.join(dir, 'same_names');
+
+    t.equal(
+        resolve.sync('./foo', { basedir: basedir }),
+        path.join(dir, 'same_names/foo.js')
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./foo', { basedir: basedir }),
+            require.resolve('./foo', { paths: [basedir] }),
+            './foo: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync('./foo/', { basedir: basedir }),
+        path.join(dir, 'same_names/foo/index.js')
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./foo/', { basedir: basedir }),
+            require.resolve('./foo/', { paths: [basedir] }),
+            './foo/: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('#211 - incorrectly resolves module-paths like "." when from inside a folder with a sibling file of the same name', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    var basedir = path.join(dir, 'same_names/foo');
+
+    t.equal(
+        resolve.sync('./', { basedir: basedir }),
+        path.join(dir, 'same_names/foo/index.js'),
+        './'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./', { basedir: basedir }),
+            require.resolve('./', { paths: [basedir] }),
+            './: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync('.', { basedir: basedir }),
+        path.join(dir, 'same_names/foo/index.js'),
+        '.'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('.', { basedir: basedir }),
+            require.resolve('.', { paths: [basedir] }),
+            '.: resolve.sync === require.resolve',
+            { todo: true }
+        );
+    }
+
+    t.end();
+});
+
+test('sync: #121 - treating an existing file as a dir when no basedir', function (t) {
+    var testFile = path.basename(__filename);
+
+    t.test('sanity check', function (st) {
+        st.equal(
+            resolve.sync('./' + testFile),
+            __filename,
+            'sanity check'
+        );
+        st.equal(
+            resolve.sync('./' + testFile),
+            require.resolve('./' + testFile),
+            'sanity check: resolve.sync === require.resolve'
+        );
+
+        st.end();
+    });
+
+    t.test('with a fake directory', function (st) {
+        function run() { return resolve.sync('./' + testFile + '/blah'); }
+
+        st.throws(run, 'throws an error');
+
+        try {
+            run();
+        } catch (e) {
+            st.equal(e.code, 'MODULE_NOT_FOUND', 'error code matches require.resolve');
+            st.equal(
+                e.message,
+                'Cannot find module \'./' + testFile + '/blah\' from \'' + __dirname + '\'',
+                'can not find nonexistent module'
+            );
+        }
+
+        st.end();
+    });
+
+    t.end();
+});
+
+test('sync dot main', function (t) {
+    var start = new Date();
+
+    t.equal(
+        resolve.sync('./resolver/dot_main'),
+        path.join(__dirname, 'resolver/dot_main/index.js'),
+        './resolver/dot_main'
+    );
+    t.equal(
+        resolve.sync('./resolver/dot_main'),
+        require.resolve('./resolver/dot_main'),
+        './resolver/dot_main: resolve.sync === require.resolve'
+    );
+
+    t.ok(new Date() - start < 50, 'resolve.sync timedout');
+
+    t.end();
+});
+
+test('sync dot slash main', function (t) {
+    var start = new Date();
+
+    t.equal(
+        resolve.sync('./resolver/dot_slash_main'),
+        path.join(__dirname, 'resolver/dot_slash_main/index.js')
+    );
+    t.equal(
+        resolve.sync('./resolver/dot_slash_main'),
+        require.resolve('./resolver/dot_slash_main'),
+        './resolver/dot_slash_main: resolve.sync === require.resolve'
+    );
+
+    t.ok(new Date() - start < 50, 'resolve.sync timedout');
+
+    t.end();
+});
+
+test('not a directory', function (t) {
+    var path = './foo';
+    try {
+        resolve.sync(path, { basedir: __filename });
+        t.fail();
+    } catch (err) {
+        t.ok(err, 'a non-directory errors');
+        t.equal(err && err.message, 'Cannot find module \'' + path + "' from '" + __filename + "'");
+        t.equal(err && err.code, 'MODULE_NOT_FOUND');
+    }
+    t.end();
+});
+
+test('non-string "main" field in package.json', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    try {
+        var result = resolve.sync('./invalid_main', { basedir: dir });
+        t.equal(result, undefined, 'result should not exist');
+        t.fail('should not get here');
+    } catch (err) {
+        t.ok(err, 'errors on non-string main');
+        t.equal(err.message, 'package “invalid_main” `main` must be a string');
+        t.equal(err.code, 'INVALID_PACKAGE_MAIN');
+    }
+    t.end();
+});
+
+test('non-string "main" field in package.json', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    try {
+        var result = resolve.sync('./invalid_main', { basedir: dir });
+        t.equal(result, undefined, 'result should not exist');
+        t.fail('should not get here');
+    } catch (err) {
+        t.ok(err, 'errors on non-string main');
+        t.equal(err.message, 'package “invalid_main” `main` must be a string');
+        t.equal(err.code, 'INVALID_PACKAGE_MAIN');
+    }
+    t.end();
+});
+
+test('browser field in package.json', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    var res = resolve.sync('./browser_field', {
+        basedir: dir,
+        packageFilter: function packageFilter(pkg) {
+            if (pkg.browser) {
+                pkg.main = pkg.browser; // eslint-disable-line no-param-reassign
+                delete pkg.browser; // eslint-disable-line no-param-reassign
+            }
+            return pkg;
+        }
+    });
+    t.equal(res, path.join(dir, 'browser_field', 'b.js'));
+    t.end();
+});
+
+test('absolute paths', function (t) {
+    var extensionless = __filename.slice(0, -path.extname(__filename).length);
+
+    t.equal(
+        resolve.sync(__filename),
+        __filename,
+        'absolute path to this file resolves'
+    );
+    t.equal(
+        resolve.sync(__filename),
+        require.resolve(__filename),
+        'absolute path to this file: resolve.sync === require.resolve'
+    );
+
+    t.equal(
+        resolve.sync(extensionless),
+        __filename,
+        'extensionless absolute path to this file resolves'
+    );
+    t.equal(
+        resolve.sync(__filename),
+        require.resolve(__filename),
+        'absolute path to this file: resolve.sync === require.resolve'
+    );
+
+    t.equal(
+        resolve.sync(__filename, { basedir: process.cwd() }),
+        __filename,
+        'absolute path to this file with a basedir resolves'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync(__filename, { basedir: process.cwd() }),
+            require.resolve(__filename, { paths: [process.cwd()] }),
+            'absolute path to this file + basedir: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync(extensionless, { basedir: process.cwd() }),
+        __filename,
+        'extensionless absolute path to this file with a basedir resolves'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync(extensionless, { basedir: process.cwd() }),
+            require.resolve(extensionless, { paths: [process.cwd()] }),
+            'extensionless absolute path to this file + basedir: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+var malformedDir = path.join(__dirname, 'resolver/malformed_package_json');
+test('malformed package.json', { skip: !fs.existsSync(malformedDir) }, function (t) {
+    t.plan(5 + (requireResolveSupportsPaths ? 1 : 0));
+
+    var basedir = malformedDir;
+    var expected = path.join(basedir, 'index.js');
+
+    t.equal(
+        resolve.sync('./index.js', { basedir: basedir }),
+        expected,
+        'malformed package.json is silently ignored'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./index.js', { basedir: basedir }),
+            require.resolve('./index.js', { paths: [basedir] }),
+            'malformed package.json: resolve.sync === require.resolve'
+        );
+    }
+
+    var res1 = resolve.sync(
+        './index.js',
+        {
+            basedir: basedir,
+            packageFilter: function (pkg, pkgfile, dir) {
+                t.fail('should not reach here');
+            }
+        }
+    );
+
+    t.equal(
+        res1,
+        expected,
+        'with packageFilter: malformed package.json is silently ignored'
+    );
+
+    var res2 = resolve.sync(
+        './index.js',
+        {
+            basedir: basedir,
+            readPackageSync: function (readFileSync, pkgfile) {
+                t.equal(pkgfile, path.join(basedir, 'package.json'), 'readPackageSync: `pkgfile` is package.json path');
+                var result = String(readFileSync(pkgfile));
+                try {
+                    return JSON.parse(result);
+                } catch (e) {
+                    t.ok(e instanceof SyntaxError, 'readPackageSync: malformed package.json parses as a syntax error');
+                }
+            }
+        }
+    );
+
+    t.equal(
+        res2,
+        expected,
+        'with readPackageSync: malformed package.json is silently ignored'
+    );
+});
diff --git a/tools/ui/node_modules/resolve/test/shadowed_core.js b/tools/ui/node_modules/resolve/test/shadowed_core.js
new file mode 100644
index 0000000000000000000000000000000000000000..3a5f4fcff728f305c2d3d17a416fea4cbfe31f6b
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/shadowed_core.js
@@ -0,0 +1,54 @@
+var test = require('tape');
+var resolve = require('../');
+var path = require('path');
+
+test('shadowed core modules still return core module', function (t) {
+    t.plan(2);
+
+    resolve('util', { basedir: path.join(__dirname, 'shadowed_core') }, function (err, res) {
+        t.ifError(err);
+        t.equal(res, 'util');
+    });
+});
+
+test('shadowed core modules still return core module [sync]', function (t) {
+    t.plan(1);
+
+    var res = resolve.sync('util', { basedir: path.join(__dirname, 'shadowed_core') });
+
+    t.equal(res, 'util');
+});
+
+test('shadowed core modules return shadow when appending `/`', function (t) {
+    t.plan(2);
+
+    resolve('util/', { basedir: path.join(__dirname, 'shadowed_core') }, function (err, res) {
+        t.ifError(err);
+        t.equal(res, path.join(__dirname, 'shadowed_core/node_modules/util/index.js'));
+    });
+});
+
+test('shadowed core modules return shadow when appending `/` [sync]', function (t) {
+    t.plan(1);
+
+    var res = resolve.sync('util/', { basedir: path.join(__dirname, 'shadowed_core') });
+
+    t.equal(res, path.join(__dirname, 'shadowed_core/node_modules/util/index.js'));
+});
+
+test('shadowed core modules return shadow with `includeCoreModules: false`', function (t) {
+    t.plan(2);
+
+    resolve('util', { basedir: path.join(__dirname, 'shadowed_core'), includeCoreModules: false }, function (err, res) {
+        t.ifError(err);
+        t.equal(res, path.join(__dirname, 'shadowed_core/node_modules/util/index.js'));
+    });
+});
+
+test('shadowed core modules return shadow with `includeCoreModules: false` [sync]', function (t) {
+    t.plan(1);
+
+    var res = resolve.sync('util', { basedir: path.join(__dirname, 'shadowed_core'), includeCoreModules: false });
+
+    t.equal(res, path.join(__dirname, 'shadowed_core/node_modules/util/index.js'));
+});
diff --git a/tools/ui/node_modules/resolve/test/shadowed_core/node_modules/util/index.js b/tools/ui/node_modules/resolve/test/shadowed_core/node_modules/util/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/ui/node_modules/resolve/test/subdirs.js b/tools/ui/node_modules/resolve/test/subdirs.js
new file mode 100644
index 0000000000000000000000000000000000000000..b7b8450a9ef231940eca37b8fe951310147a9470
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/subdirs.js
@@ -0,0 +1,13 @@
+var test = require('tape');
+var resolve = require('../');
+var path = require('path');
+
+test('subdirs', function (t) {
+    t.plan(2);
+
+    var dir = path.join(__dirname, '/subdirs');
+    resolve('a/b/c/x.json', { basedir: dir }, function (err, res) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, 'node_modules/a/b/c/x.json'));
+    });
+});
diff --git a/tools/ui/node_modules/resolve/test/symlinks.js b/tools/ui/node_modules/resolve/test/symlinks.js
new file mode 100644
index 0000000000000000000000000000000000000000..35f881afb8c7e043567cf85953d9046c011cec3d
--- /dev/null
+++ b/tools/ui/node_modules/resolve/test/symlinks.js
@@ -0,0 +1,176 @@
+var path = require('path');
+var fs = require('fs');
+var test = require('tape');
+var map = require('array.prototype.map');
+var resolve = require('../');
+
+var symlinkDir = path.join(__dirname, 'resolver', 'symlinked', 'symlink');
+var packageDir = path.join(__dirname, 'resolver', 'symlinked', '_', 'node_modules', 'package');
+var modADir = path.join(__dirname, 'symlinks', 'source', 'node_modules', 'mod-a');
+var symlinkModADir = path.join(__dirname, 'symlinks', 'dest', 'node_modules', 'mod-a');
+try {
+    fs.unlinkSync(symlinkDir);
+} catch (err) {}
+try {
+    fs.unlinkSync(packageDir);
+} catch (err) {}
+try {
+    fs.unlinkSync(modADir);
+} catch (err) {}
+try {
+    fs.unlinkSync(symlinkModADir);
+} catch (err) {}
+
+try {
+    fs.symlinkSync('./_/symlink_target', symlinkDir, 'dir');
+} catch (err) {
+    // if fails then it is probably on Windows and lets try to create a junction
+    fs.symlinkSync(path.join(__dirname, 'resolver', 'symlinked', '_', 'symlink_target') + '\\', symlinkDir, 'junction');
+}
+try {
+    fs.symlinkSync('../../package', packageDir, 'dir');
+} catch (err) {
+    // if fails then it is probably on Windows and lets try to create a junction
+    fs.symlinkSync(path.join(__dirname, '..', '..', 'package') + '\\', packageDir, 'junction');
+}
+try {
+    fs.symlinkSync('../../source/node_modules/mod-a', symlinkModADir, 'dir');
+} catch (err) {
+    // if fails then it is probably on Windows and lets try to create a junction
+    fs.symlinkSync(path.join(__dirname, '..', '..', 'source', 'node_modules', 'mod-a') + '\\', symlinkModADir, 'junction');
+}
+
+test('symlink', function (t) {
+    t.plan(2);
+
+    resolve('foo', { basedir: symlinkDir, preserveSymlinks: false }, function (err, res, pkg) {
+        t.error(err);
+        t.equal(res, path.join(__dirname, 'resolver', 'symlinked', '_', 'node_modules', 'foo.js'));
+    });
+});
+
+test('sync symlink when preserveSymlinks = true', function (t) {
+    t.plan(4);
+
+    resolve('foo', { basedir: symlinkDir }, function (err, res, pkg) {
+        t.ok(err, 'there is an error');
+        t.notOk(res, 'no result');
+
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error code matches require.resolve');
+        t.equal(
+            err && err.message,
+            'Cannot find module \'foo\' from \'' + symlinkDir + '\'',
+            'can not find nonexistent module'
+        );
+    });
+});
+
+test('sync symlink', function (t) {
+    var start = new Date();
+    t.doesNotThrow(function () {
+        t.equal(
+            resolve.sync('foo', { basedir: symlinkDir, preserveSymlinks: false }),
+            path.join(__dirname, 'resolver', 'symlinked', '_', 'node_modules', 'foo.js')
+        );
+    });
+    t.ok(new Date() - start < 50, 'resolve.sync timedout');
+    t.end();
+});
+
+test('sync symlink when preserveSymlinks = true', function (t) {
+    t.throws(function () {
+        resolve.sync('foo', { basedir: symlinkDir });
+    }, /Cannot find module 'foo'/);
+    t.end();
+});
+
+test('sync symlink from node_modules to other dir when preserveSymlinks = false', function (t) {
+    var basedir = path.join(__dirname, 'resolver', 'symlinked', '_');
+    var fn = resolve.sync('package', { basedir: basedir, preserveSymlinks: false });
+
+    t.equal(fn, path.resolve(__dirname, 'resolver/symlinked/package/bar.js'));
+    t.end();
+});
+
+test('async symlink from node_modules to other dir when preserveSymlinks = false', function (t) {
+    t.plan(2);
+    var basedir = path.join(__dirname, 'resolver', 'symlinked', '_');
+    resolve('package', { basedir: basedir, preserveSymlinks: false }, function (err, result) {
+        t.notOk(err, 'no error');
+        t.equal(result, path.resolve(__dirname, 'resolver/symlinked/package/bar.js'));
+    });
+});
+
+test('packageFilter', function (t) {
+    function relative(x) {
+        return path.relative(__dirname, x);
+    }
+
+    function testPackageFilter(preserveSymlinks) {
+        return function (st) {
+            st.plan('is 1.x' ? 3 : 5); // eslint-disable-line no-constant-condition
+
+            var destMain = 'symlinks/dest/node_modules/mod-a/index.js';
+            var destPkg = 'symlinks/dest/node_modules/mod-a/package.json';
+            var sourceMain = 'symlinks/source/node_modules/mod-a/index.js';
+            var sourcePkg = 'symlinks/source/node_modules/mod-a/package.json';
+            var destDir = path.join(__dirname, 'symlinks', 'dest');
+
+            /* eslint multiline-comment-style: 0 */
+            /* v2.x will restore these tests
+            var packageFilterPath = [];
+            var actualPath = resolve.sync('mod-a', {
+                basedir: destDir,
+                preserveSymlinks: preserveSymlinks,
+                packageFilter: function (pkg, pkgfile, dir) {
+                    packageFilterPath.push(pkgfile);
+                }
+            });
+            st.equal(
+                relative(actualPath),
+                path.normalize(preserveSymlinks ? destMain : sourceMain),
+                'sync: actual path is correct'
+            );
+            st.deepEqual(
+                map(packageFilterPath, relative),
+                map(preserveSymlinks ? [destPkg, destPkg] : [sourcePkg, sourcePkg], path.normalize),
+                'sync: packageFilter pkgfile arg is correct'
+            );
+            */
+
+            var asyncPackageFilterPath = [];
+            resolve(
+                'mod-a',
+                {
+                    basedir: destDir,
+                    preserveSymlinks: preserveSymlinks,
+                    packageFilter: function (pkg, pkgfile) {
+                        asyncPackageFilterPath.push(pkgfile);
+                    }
+                },
+                function (err, actualPath) {
+                    st.error(err, 'no error');
+                    st.equal(
+                        relative(actualPath),
+                        path.normalize(preserveSymlinks ? destMain : sourceMain),
+                        'async: actual path is correct'
+                    );
+                    st.deepEqual(
+                        map(asyncPackageFilterPath, relative),
+                        map(
+                            preserveSymlinks ? [destPkg, destPkg, destPkg] : [sourcePkg, sourcePkg, sourcePkg],
+                            path.normalize
+                        ),
+                        'async: packageFilter pkgfile arg is correct'
+                    );
+                }
+            );
+        };
+    }
+
+    t.test('preserveSymlinks: false', testPackageFilter(false));
+
+    t.test('preserveSymlinks: true', testPackageFilter(true));
+
+    t.end();
+});
diff --git a/tools/ui/node_modules/robust-predicates/LICENSE b/tools/ui/node_modules/robust-predicates/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..cf1ab25da0349f84a3fdd40032f0ce99db813b8b
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/LICENSE
@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to 
diff --git a/tools/ui/node_modules/robust-predicates/README.md b/tools/ui/node_modules/robust-predicates/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4d06cf06076e3335d97df447e3ef9887a8dd4cdc
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/README.md
@@ -0,0 +1,82 @@
+# robust-predicates
+
+Fast robust predicates for computational geometry in JavaScript. Provides reliable 2D and 3D point orientation tests (`orient2d`, `orient3d`, `incircle`, `insphere`) that are not susceptible to floating point errors (without sacrificing performance). A modern port of [Jonathan R Shewchuk's C code](https://www.cs.cmu.edu/~quake/robust.html), an industry standard since 1996.
+
+
+
+_Figure: non-robust vs robust `orient2d` test for points within a tiny range (2-42)._
+
+[![Build Status](https://github.com/mourner/robust-predicates/actions/workflows/node.yml/badge.svg)](https://github.com/mourner/robust-predicates/actions/workflows/node.yml)
+[![Simply Awesome](https://img.shields.io/badge/simply-awesome-brightgreen.svg)](https://github.com/mourner/projects)
+[![Browser Build](https://img.shields.io/bundlephobia/minzip/robust-predicates)](https://unpkg.com/robust-predicates)
+
+## [Demo](https://observablehq.com/@mourner/non-robust-arithmetic-as-art)
+
+## API
+
+Note: unlike J. Shewchuk's original code, all the functions in this library assume `y` axis is oriented _downwards_ ↓, so the semantics are different.
+
+### `orient2d(ax,ay, bx,by, cx,cy)`
+
+- Returns a *positive* value if the points `a`, `b`, and `c` occur in _counterclockwise_ order (`c` lies to the left of the directed line defined by points `a` and `b`).
+- Returns a *negative* value if they occur in _clockwise_ order (`c` lies to the right of the directed line `ab`).
+- Returns *zero* if they are _collinear_.
+
+The result is also an approximation of twice the signed area of the triangle defined by the three points.
+
+### `incircle(ax,ay, bx,by, cx,cy, dx,dy)`
+
+- Returns a _positive_ value if the point `d` lies _outside_ the circle passing through `a`, `b`, and `c`.
+- Returns a _negative_ value if it lies _inside_.
+- Returns _zero_ if the four points are _cocircular_.
+
+The points `a`, `b`, and `c` must be in _counterclockwise_ order, or the sign of the result will be reversed.
+
+### `orient3d(ax,ay,az, bx,by,bz, cx,cy,cz, dx,dy,dz)`
+
+- Returns a _positive_ value if the point `d` lies _above_ the plane passing through `a`, `b`, and `c`, meaning that `a`, `b`, and `c` appear in counterclockwise order when viewed from `d`.
+- Returns a _negative_ value if `d` lies _below_ the plane.
+- Returns _zero_ if the points are _coplanar_.
+
+The result is also an approximation of six times the signed volume of the tetrahedron defined by the four points.
+
+### `insphere(ax,ay,az, bx,by,bz, cx,cy,cz, dx,dy,dz, ex,ey,ez)`
+
+- Returns a _positive_ value if the point `e` lies _outside_ the sphere passing through `a`, `b`, `c`, and `d`.
+- Returns a _negative_ value if it lies _inside_.
+- Returns _zero_ if the five points are _cospherical_.
+
+The points `a`, `b`, `c`, and `d` must be ordered so that they have a _positive orientation_
+(as defined by `orient3d`), or the sign of the result will be reversed.
+
+### `orient2dfast`, `orient3dfast`, `incirclefast`, `inspherefast`
+
+Simple, approximate, non-robust versions of predicates above. Use when robustness isn't needed.
+
+## Example
+
+```js
+import {orient2d} from 'robust-predicates';
+
+const ccw = orient2d(ax, ay, bx, by, cx, cy) > 0;
+````
+
+## Install
+
+Install with `npm install robust-predicates` or `yarn add robust-predicates`, or use one of the browser builds:
+
+- [predicates.min.js](https://unpkg.com/robust-predicates/umd/predicates.min.js) (all predicates)
+- [orient2d.min.js](https://unpkg.com/robust-predicates/umd/orient2d.min.js) (`orient2d`, `orient2dfast`)
+- [orient3d.min.js](https://unpkg.com/robust-predicates/umd/orient3d.min.js) (`orient3d`, `orient3dfast`)
+- [incircle.min.js](https://unpkg.com/robust-predicates/umd/incircle.min.js) (`incircle`, `incirclefast`)
+- [insphere.min.js](https://unpkg.com/robust-predicates/umd/insphere.min.js) (`insphere`, `inspherefast`)
+
+## Thanks
+
+This project is just a port — all the brilliant, hard work was done by [Jonathan Richard Shewchuk](https://people.eecs.berkeley.edu/~jrs/).
+
+The port was also inspired by [Mikola Lysenko](https://twitter.com/MikolaLysenko)'s excellent [Robust Arithmetic Notes](https://github.com/mikolalysenko/robust-arithmetic-notes) and related projects like [robust-orientation](https://github.com/mikolalysenko/robust-orientation) and [robust-in-sphere](https://github.com/mikolalysenko/robust-in-sphere).
+
+## License
+
+Since the original code is in the public domain, this project follows the same choice. See [Unlicense](https://unlicense.org).
diff --git a/tools/ui/node_modules/robust-predicates/esm/incircle.js b/tools/ui/node_modules/robust-predicates/esm/incircle.js
new file mode 100644
index 0000000000000000000000000000000000000000..77b7301c738c093ddfafa6bedf4bd1e7330a5b36
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/esm/incircle.js
@@ -0,0 +1,765 @@
+import {epsilon, splitter, resulterrbound, estimate, vec, sum, sum_three, scale} from './util.js';
+
+const iccerrboundA = (10 + 96 * epsilon) * epsilon;
+const iccerrboundB = (4 + 48 * epsilon) * epsilon;
+const iccerrboundC = (44 + 576 * epsilon) * epsilon * epsilon;
+
+const bc = vec(4);
+const ca = vec(4);
+const ab = vec(4);
+const aa = vec(4);
+const bb = vec(4);
+const cc = vec(4);
+const u = vec(4);
+const v = vec(4);
+const axtbc = vec(8);
+const aytbc = vec(8);
+const bxtca = vec(8);
+const bytca = vec(8);
+const cxtab = vec(8);
+const cytab = vec(8);
+const abt = vec(8);
+const bct = vec(8);
+const cat = vec(8);
+const abtt = vec(4);
+const bctt = vec(4);
+const catt = vec(4);
+
+const _8 = vec(8);
+const _16 = vec(16);
+const _16b = vec(16);
+const _16c = vec(16);
+const _32 = vec(32);
+const _32b = vec(32);
+const _48 = vec(48);
+const _64 = vec(64);
+
+let fin = vec(1152);
+let fin2 = vec(1152);
+
+function finadd(finlen, a, alen) {
+    finlen = sum(finlen, fin, a, alen, fin2);
+    const tmp = fin; fin = fin2; fin2 = tmp;
+    return finlen;
+}
+
+function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
+    let finlen;
+    let adxtail, bdxtail, cdxtail, adytail, bdytail, cdytail;
+    let axtbclen, aytbclen, bxtcalen, bytcalen, cxtablen, cytablen;
+    let abtlen, bctlen, catlen;
+    let abttlen, bcttlen, cattlen;
+    let n1, n0;
+
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+
+    s1 = bdx * cdy;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cdx * bdy;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bc[3] = u3;
+    s1 = cdx * ady;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = adx * cdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ca[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ca[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ca[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ca[3] = u3;
+    s1 = adx * bdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bdx * ady;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ab[3] = u3;
+
+    finlen = sum(
+        sum(
+            sum(
+                scale(scale(4, bc, adx, _8), _8, adx, _16), _16,
+                scale(scale(4, bc, ady, _8), _8, ady, _16b), _16b, _32), _32,
+            sum(
+                scale(scale(4, ca, bdx, _8), _8, bdx, _16), _16,
+                scale(scale(4, ca, bdy, _8), _8, bdy, _16b), _16b, _32b), _32b, _64), _64,
+        sum(
+            scale(scale(4, ab, cdx, _8), _8, cdx, _16), _16,
+            scale(scale(4, ab, cdy, _8), _8, cdy, _16b), _16b, _32), _32, fin);
+
+    let det = estimate(finlen, fin);
+    let errbound = iccerrboundB * permanent;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - adx;
+    adxtail = ax - (adx + bvirt) + (bvirt - dx);
+    bvirt = ay - ady;
+    adytail = ay - (ady + bvirt) + (bvirt - dy);
+    bvirt = bx - bdx;
+    bdxtail = bx - (bdx + bvirt) + (bvirt - dx);
+    bvirt = by - bdy;
+    bdytail = by - (bdy + bvirt) + (bvirt - dy);
+    bvirt = cx - cdx;
+    cdxtail = cx - (cdx + bvirt) + (bvirt - dx);
+    bvirt = cy - cdy;
+    cdytail = cy - (cdy + bvirt) + (bvirt - dy);
+    if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 && adytail === 0 && bdytail === 0 && cdytail === 0) {
+        return det;
+    }
+
+    errbound = iccerrboundC * permanent + resulterrbound * Math.abs(det);
+    det += ((adx * adx + ady * ady) * ((bdx * cdytail + cdy * bdxtail) - (bdy * cdxtail + cdx * bdytail)) +
+        2 * (adx * adxtail + ady * adytail) * (bdx * cdy - bdy * cdx)) +
+        ((bdx * bdx + bdy * bdy) * ((cdx * adytail + ady * cdxtail) - (cdy * adxtail + adx * cdytail)) +
+        2 * (bdx * bdxtail + bdy * bdytail) * (cdx * ady - cdy * adx)) +
+        ((cdx * cdx + cdy * cdy) * ((adx * bdytail + bdy * adxtail) - (ady * bdxtail + bdx * adytail)) +
+        2 * (cdx * cdxtail + cdy * cdytail) * (adx * bdy - ady * bdx));
+
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {
+        s1 = adx * adx;
+        c = splitter * adx;
+        ahi = c - (c - adx);
+        alo = adx - ahi;
+        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
+        t1 = ady * ady;
+        c = splitter * ady;
+        ahi = c - (c - ady);
+        alo = ady - ahi;
+        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
+        _i = s0 + t0;
+        bvirt = _i - s0;
+        aa[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        aa[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        aa[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        aa[3] = u3;
+    }
+    if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {
+        s1 = bdx * bdx;
+        c = splitter * bdx;
+        ahi = c - (c - bdx);
+        alo = bdx - ahi;
+        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
+        t1 = bdy * bdy;
+        c = splitter * bdy;
+        ahi = c - (c - bdy);
+        alo = bdy - ahi;
+        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
+        _i = s0 + t0;
+        bvirt = _i - s0;
+        bb[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        bb[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        bb[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        bb[3] = u3;
+    }
+    if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {
+        s1 = cdx * cdx;
+        c = splitter * cdx;
+        ahi = c - (c - cdx);
+        alo = cdx - ahi;
+        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
+        t1 = cdy * cdy;
+        c = splitter * cdy;
+        ahi = c - (c - cdy);
+        alo = cdy - ahi;
+        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
+        _i = s0 + t0;
+        bvirt = _i - s0;
+        cc[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        cc[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        cc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        cc[3] = u3;
+    }
+
+    if (adxtail !== 0) {
+        axtbclen = scale(4, bc, adxtail, axtbc);
+        finlen = finadd(finlen, sum_three(
+            scale(axtbclen, axtbc, 2 * adx, _16), _16,
+            scale(scale(4, cc, adxtail, _8), _8, bdy, _16b), _16b,
+            scale(scale(4, bb, adxtail, _8), _8, -cdy, _16c), _16c, _32, _48), _48);
+    }
+    if (adytail !== 0) {
+        aytbclen = scale(4, bc, adytail, aytbc);
+        finlen = finadd(finlen, sum_three(
+            scale(aytbclen, aytbc, 2 * ady, _16), _16,
+            scale(scale(4, bb, adytail, _8), _8, cdx, _16b), _16b,
+            scale(scale(4, cc, adytail, _8), _8, -bdx, _16c), _16c, _32, _48), _48);
+    }
+    if (bdxtail !== 0) {
+        bxtcalen = scale(4, ca, bdxtail, bxtca);
+        finlen = finadd(finlen, sum_three(
+            scale(bxtcalen, bxtca, 2 * bdx, _16), _16,
+            scale(scale(4, aa, bdxtail, _8), _8, cdy, _16b), _16b,
+            scale(scale(4, cc, bdxtail, _8), _8, -ady, _16c), _16c, _32, _48), _48);
+    }
+    if (bdytail !== 0) {
+        bytcalen = scale(4, ca, bdytail, bytca);
+        finlen = finadd(finlen, sum_three(
+            scale(bytcalen, bytca, 2 * bdy, _16), _16,
+            scale(scale(4, cc, bdytail, _8), _8, adx, _16b), _16b,
+            scale(scale(4, aa, bdytail, _8), _8, -cdx, _16c), _16c, _32, _48), _48);
+    }
+    if (cdxtail !== 0) {
+        cxtablen = scale(4, ab, cdxtail, cxtab);
+        finlen = finadd(finlen, sum_three(
+            scale(cxtablen, cxtab, 2 * cdx, _16), _16,
+            scale(scale(4, bb, cdxtail, _8), _8, ady, _16b), _16b,
+            scale(scale(4, aa, cdxtail, _8), _8, -bdy, _16c), _16c, _32, _48), _48);
+    }
+    if (cdytail !== 0) {
+        cytablen = scale(4, ab, cdytail, cytab);
+        finlen = finadd(finlen, sum_three(
+            scale(cytablen, cytab, 2 * cdy, _16), _16,
+            scale(scale(4, aa, cdytail, _8), _8, bdx, _16b), _16b,
+            scale(scale(4, bb, cdytail, _8), _8, -adx, _16c), _16c, _32, _48), _48);
+    }
+
+    if (adxtail !== 0 || adytail !== 0) {
+        if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {
+            s1 = bdxtail * cdy;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * cdy;
+            bhi = c - (c - cdy);
+            blo = cdy - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = bdx * cdytail;
+            c = splitter * bdx;
+            ahi = c - (c - bdx);
+            alo = bdx - ahi;
+            c = splitter * cdytail;
+            bhi = c - (c - cdytail);
+            blo = cdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
+            s1 = cdxtail * -bdy;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * -bdy;
+            bhi = c - (c - -bdy);
+            blo = -bdy - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdx * -bdytail;
+            c = splitter * cdx;
+            ahi = c - (c - cdx);
+            alo = cdx - ahi;
+            c = splitter * -bdytail;
+            bhi = c - (c - -bdytail);
+            blo = -bdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            v[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            v[3] = u3;
+            bctlen = sum(4, u, 4, v, bct);
+            s1 = bdxtail * cdytail;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * cdytail;
+            bhi = c - (c - cdytail);
+            blo = cdytail - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdxtail * bdytail;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * bdytail;
+            bhi = c - (c - bdytail);
+            blo = bdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 - t0;
+            bvirt = s0 - _i;
+            bctt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            bctt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            bctt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            bctt[3] = u3;
+            bcttlen = 4;
+        } else {
+            bct[0] = 0;
+            bctlen = 1;
+            bctt[0] = 0;
+            bcttlen = 1;
+        }
+        if (adxtail !== 0) {
+            const len = scale(bctlen, bct, adxtail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(axtbclen, axtbc, adxtail, _16), _16,
+                scale(len, _16c, 2 * adx, _32), _32, _48), _48);
+
+            const len2 = scale(bcttlen, bctt, adxtail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * adx, _16), _16,
+                scale(len2, _8, adxtail, _16b), _16b,
+                scale(len, _16c, adxtail, _32), _32, _32b, _64), _64);
+
+            if (bdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, cc, adxtail, _8), _8, bdytail, _16), _16);
+            }
+            if (cdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, bb, -adxtail, _8), _8, cdytail, _16), _16);
+            }
+        }
+        if (adytail !== 0) {
+            const len = scale(bctlen, bct, adytail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(aytbclen, aytbc, adytail, _16), _16,
+                scale(len, _16c, 2 * ady, _32), _32, _48), _48);
+
+            const len2 = scale(bcttlen, bctt, adytail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * ady, _16), _16,
+                scale(len2, _8, adytail, _16b), _16b,
+                scale(len, _16c, adytail, _32), _32, _32b, _64), _64);
+        }
+    }
+    if (bdxtail !== 0 || bdytail !== 0) {
+        if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {
+            s1 = cdxtail * ady;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * ady;
+            bhi = c - (c - ady);
+            blo = ady - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdx * adytail;
+            c = splitter * cdx;
+            ahi = c - (c - cdx);
+            alo = cdx - ahi;
+            c = splitter * adytail;
+            bhi = c - (c - adytail);
+            blo = adytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
+            n1 = -cdy;
+            n0 = -cdytail;
+            s1 = adxtail * n1;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * n1;
+            bhi = c - (c - n1);
+            blo = n1 - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = adx * n0;
+            c = splitter * adx;
+            ahi = c - (c - adx);
+            alo = adx - ahi;
+            c = splitter * n0;
+            bhi = c - (c - n0);
+            blo = n0 - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            v[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            v[3] = u3;
+            catlen = sum(4, u, 4, v, cat);
+            s1 = cdxtail * adytail;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * adytail;
+            bhi = c - (c - adytail);
+            blo = adytail - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = adxtail * cdytail;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * cdytail;
+            bhi = c - (c - cdytail);
+            blo = cdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 - t0;
+            bvirt = s0 - _i;
+            catt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            catt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            catt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            catt[3] = u3;
+            cattlen = 4;
+        } else {
+            cat[0] = 0;
+            catlen = 1;
+            catt[0] = 0;
+            cattlen = 1;
+        }
+        if (bdxtail !== 0) {
+            const len = scale(catlen, cat, bdxtail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(bxtcalen, bxtca, bdxtail, _16), _16,
+                scale(len, _16c, 2 * bdx, _32), _32, _48), _48);
+
+            const len2 = scale(cattlen, catt, bdxtail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * bdx, _16), _16,
+                scale(len2, _8, bdxtail, _16b), _16b,
+                scale(len, _16c, bdxtail, _32), _32, _32b, _64), _64);
+
+            if (cdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, aa, bdxtail, _8), _8, cdytail, _16), _16);
+            }
+            if (adytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, cc, -bdxtail, _8), _8, adytail, _16), _16);
+            }
+        }
+        if (bdytail !== 0) {
+            const len = scale(catlen, cat, bdytail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(bytcalen, bytca, bdytail, _16), _16,
+                scale(len, _16c, 2 * bdy, _32), _32, _48), _48);
+
+            const len2 = scale(cattlen, catt, bdytail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * bdy, _16), _16,
+                scale(len2, _8, bdytail, _16b), _16b,
+                scale(len, _16c, bdytail, _32), _32,  _32b, _64), _64);
+        }
+    }
+    if (cdxtail !== 0 || cdytail !== 0) {
+        if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {
+            s1 = adxtail * bdy;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * bdy;
+            bhi = c - (c - bdy);
+            blo = bdy - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = adx * bdytail;
+            c = splitter * adx;
+            ahi = c - (c - adx);
+            alo = adx - ahi;
+            c = splitter * bdytail;
+            bhi = c - (c - bdytail);
+            blo = bdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
+            n1 = -ady;
+            n0 = -adytail;
+            s1 = bdxtail * n1;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * n1;
+            bhi = c - (c - n1);
+            blo = n1 - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = bdx * n0;
+            c = splitter * bdx;
+            ahi = c - (c - bdx);
+            alo = bdx - ahi;
+            c = splitter * n0;
+            bhi = c - (c - n0);
+            blo = n0 - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            v[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            v[3] = u3;
+            abtlen = sum(4, u, 4, v, abt);
+            s1 = adxtail * bdytail;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * bdytail;
+            bhi = c - (c - bdytail);
+            blo = bdytail - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = bdxtail * adytail;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * adytail;
+            bhi = c - (c - adytail);
+            blo = adytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 - t0;
+            bvirt = s0 - _i;
+            abtt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            abtt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            abtt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            abtt[3] = u3;
+            abttlen = 4;
+        } else {
+            abt[0] = 0;
+            abtlen = 1;
+            abtt[0] = 0;
+            abttlen = 1;
+        }
+        if (cdxtail !== 0) {
+            const len = scale(abtlen, abt, cdxtail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(cxtablen, cxtab, cdxtail, _16), _16,
+                scale(len, _16c, 2 * cdx, _32), _32, _48), _48);
+
+            const len2 = scale(abttlen, abtt, cdxtail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * cdx, _16), _16,
+                scale(len2, _8, cdxtail, _16b), _16b,
+                scale(len, _16c, cdxtail, _32), _32, _32b, _64), _64);
+
+            if (adytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, bb, cdxtail, _8), _8, adytail, _16), _16);
+            }
+            if (bdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, aa, -cdxtail, _8), _8, bdytail, _16), _16);
+            }
+        }
+        if (cdytail !== 0) {
+            const len = scale(abtlen, abt, cdytail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(cytablen, cytab, cdytail, _16), _16,
+                scale(len, _16c, 2 * cdy, _32), _32, _48), _48);
+
+            const len2 = scale(abttlen, abtt, cdytail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * cdy, _16), _16,
+                scale(len2, _8, cdytail, _16b), _16b,
+                scale(len, _16c, cdytail, _32), _32, _32b, _64), _64);
+        }
+    }
+
+    return fin[finlen - 1];
+}
+
+export function incircle(ax, ay, bx, by, cx, cy, dx, dy) {
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+
+    const bdxcdy = bdx * cdy;
+    const cdxbdy = cdx * bdy;
+    const alift = adx * adx + ady * ady;
+
+    const cdxady = cdx * ady;
+    const adxcdy = adx * cdy;
+    const blift = bdx * bdx + bdy * bdy;
+
+    const adxbdy = adx * bdy;
+    const bdxady = bdx * ady;
+    const clift = cdx * cdx + cdy * cdy;
+
+    const det =
+        alift * (bdxcdy - cdxbdy) +
+        blift * (cdxady - adxcdy) +
+        clift * (adxbdy - bdxady);
+
+    const permanent =
+        (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * alift +
+        (Math.abs(cdxady) + Math.abs(adxcdy)) * blift +
+        (Math.abs(adxbdy) + Math.abs(bdxady)) * clift;
+
+    const errbound = iccerrboundA * permanent;
+
+    if (det > errbound || -det > errbound) {
+        return det;
+    }
+    return incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent);
+}
+
+export function incirclefast(ax, ay, bx, by, cx, cy, dx, dy) {
+    const adx = ax - dx;
+    const ady = ay - dy;
+    const bdx = bx - dx;
+    const bdy = by - dy;
+    const cdx = cx - dx;
+    const cdy = cy - dy;
+
+    const abdet = adx * bdy - bdx * ady;
+    const bcdet = bdx * cdy - cdx * bdy;
+    const cadet = cdx * ady - adx * cdy;
+    const alift = adx * adx + ady * ady;
+    const blift = bdx * bdx + bdy * bdy;
+    const clift = cdx * cdx + cdy * cdy;
+
+    return alift * bcdet + blift * cadet + clift * abdet;
+}
diff --git a/tools/ui/node_modules/robust-predicates/esm/insphere.js b/tools/ui/node_modules/robust-predicates/esm/insphere.js
new file mode 100644
index 0000000000000000000000000000000000000000..80c1119e8356d3308ef9ab039d68ee13bb6e7047
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/esm/insphere.js
@@ -0,0 +1,766 @@
+import {epsilon, splitter, resulterrbound, estimate, vec, sum, sum_three, scale, negate} from './util.js';
+
+const isperrboundA = (16 + 224 * epsilon) * epsilon;
+const isperrboundB = (5 + 72 * epsilon) * epsilon;
+const isperrboundC = (71 + 1408 * epsilon) * epsilon * epsilon;
+
+const ab = vec(4);
+const bc = vec(4);
+const cd = vec(4);
+const de = vec(4);
+const ea = vec(4);
+const ac = vec(4);
+const bd = vec(4);
+const ce = vec(4);
+const da = vec(4);
+const eb = vec(4);
+
+const abc = vec(24);
+const bcd = vec(24);
+const cde = vec(24);
+const dea = vec(24);
+const eab = vec(24);
+const abd = vec(24);
+const bce = vec(24);
+const cda = vec(24);
+const deb = vec(24);
+const eac = vec(24);
+
+const adet = vec(1152);
+const bdet = vec(1152);
+const cdet = vec(1152);
+const ddet = vec(1152);
+const edet = vec(1152);
+const abdet = vec(2304);
+const cddet = vec(2304);
+const cdedet = vec(3456);
+const deter = vec(5760);
+
+const _8 = vec(8);
+const _8b = vec(8);
+const _8c = vec(8);
+const _16 = vec(16);
+const _24 = vec(24);
+const _48 = vec(48);
+const _48b = vec(48);
+const _96 = vec(96);
+const _192 = vec(192);
+const _384x = vec(384);
+const _384y = vec(384);
+const _384z = vec(384);
+const _768 = vec(768);
+
+function sum_three_scale(a, b, c, az, bz, cz, out) {
+    return sum_three(
+        scale(4, a, az, _8), _8,
+        scale(4, b, bz, _8b), _8b,
+        scale(4, c, cz, _8c), _8c, _16, out);
+}
+
+function liftexact(alen, a, blen, b, clen, c, dlen, d, x, y, z, out) {
+    const len = sum(
+        sum(alen, a, blen, b, _48), _48,
+        negate(sum(clen, c, dlen, d, _48b), _48b), _48b, _96);
+
+    return sum_three(
+        scale(scale(len, _96, x, _192), _192, x, _384x), _384x,
+        scale(scale(len, _96, y, _192), _192, y, _384y), _384y,
+        scale(scale(len, _96, z, _192), _192, z, _384z), _384z, _768, out);
+}
+
+function insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    s1 = ax * by;
+    c = splitter * ax;
+    ahi = c - (c - ax);
+    alo = ax - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bx * ay;
+    c = splitter * bx;
+    ahi = c - (c - bx);
+    alo = bx - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ab[3] = u3;
+    s1 = bx * cy;
+    c = splitter * bx;
+    ahi = c - (c - bx);
+    alo = bx - ahi;
+    c = splitter * cy;
+    bhi = c - (c - cy);
+    blo = cy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cx * by;
+    c = splitter * cx;
+    ahi = c - (c - cx);
+    alo = cx - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bc[3] = u3;
+    s1 = cx * dy;
+    c = splitter * cx;
+    ahi = c - (c - cx);
+    alo = cx - ahi;
+    c = splitter * dy;
+    bhi = c - (c - dy);
+    blo = dy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = dx * cy;
+    c = splitter * dx;
+    ahi = c - (c - dx);
+    alo = dx - ahi;
+    c = splitter * cy;
+    bhi = c - (c - cy);
+    blo = cy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    cd[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    cd[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    cd[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    cd[3] = u3;
+    s1 = dx * ey;
+    c = splitter * dx;
+    ahi = c - (c - dx);
+    alo = dx - ahi;
+    c = splitter * ey;
+    bhi = c - (c - ey);
+    blo = ey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ex * dy;
+    c = splitter * ex;
+    ahi = c - (c - ex);
+    alo = ex - ahi;
+    c = splitter * dy;
+    bhi = c - (c - dy);
+    blo = dy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    de[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    de[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    de[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    de[3] = u3;
+    s1 = ex * ay;
+    c = splitter * ex;
+    ahi = c - (c - ex);
+    alo = ex - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ax * ey;
+    c = splitter * ax;
+    ahi = c - (c - ax);
+    alo = ax - ahi;
+    c = splitter * ey;
+    bhi = c - (c - ey);
+    blo = ey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ea[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ea[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ea[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ea[3] = u3;
+    s1 = ax * cy;
+    c = splitter * ax;
+    ahi = c - (c - ax);
+    alo = ax - ahi;
+    c = splitter * cy;
+    bhi = c - (c - cy);
+    blo = cy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cx * ay;
+    c = splitter * cx;
+    ahi = c - (c - cx);
+    alo = cx - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ac[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ac[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ac[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ac[3] = u3;
+    s1 = bx * dy;
+    c = splitter * bx;
+    ahi = c - (c - bx);
+    alo = bx - ahi;
+    c = splitter * dy;
+    bhi = c - (c - dy);
+    blo = dy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = dx * by;
+    c = splitter * dx;
+    ahi = c - (c - dx);
+    alo = dx - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bd[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bd[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bd[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bd[3] = u3;
+    s1 = cx * ey;
+    c = splitter * cx;
+    ahi = c - (c - cx);
+    alo = cx - ahi;
+    c = splitter * ey;
+    bhi = c - (c - ey);
+    blo = ey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ex * cy;
+    c = splitter * ex;
+    ahi = c - (c - ex);
+    alo = ex - ahi;
+    c = splitter * cy;
+    bhi = c - (c - cy);
+    blo = cy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ce[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ce[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ce[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ce[3] = u3;
+    s1 = dx * ay;
+    c = splitter * dx;
+    ahi = c - (c - dx);
+    alo = dx - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ax * dy;
+    c = splitter * ax;
+    ahi = c - (c - ax);
+    alo = ax - ahi;
+    c = splitter * dy;
+    bhi = c - (c - dy);
+    blo = dy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    da[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    da[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    da[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    da[3] = u3;
+    s1 = ex * by;
+    c = splitter * ex;
+    ahi = c - (c - ex);
+    alo = ex - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bx * ey;
+    c = splitter * bx;
+    ahi = c - (c - bx);
+    alo = bx - ahi;
+    c = splitter * ey;
+    bhi = c - (c - ey);
+    blo = ey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    eb[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    eb[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    eb[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    eb[3] = u3;
+
+    const abclen = sum_three_scale(ab, bc, ac, cz, az, -bz, abc);
+    const bcdlen = sum_three_scale(bc, cd, bd, dz, bz, -cz, bcd);
+    const cdelen = sum_three_scale(cd, de, ce, ez, cz, -dz, cde);
+    const dealen = sum_three_scale(de, ea, da, az, dz, -ez, dea);
+    const eablen = sum_three_scale(ea, ab, eb, bz, ez, -az, eab);
+    const abdlen = sum_three_scale(ab, bd, da, dz, az, bz, abd);
+    const bcelen = sum_three_scale(bc, ce, eb, ez, bz, cz, bce);
+    const cdalen = sum_three_scale(cd, da, ac, az, cz, dz, cda);
+    const deblen = sum_three_scale(de, eb, bd, bz, dz, ez, deb);
+    const eaclen = sum_three_scale(ea, ac, ce, cz, ez, az, eac);
+
+    const deterlen = sum_three(
+        liftexact(cdelen, cde, bcelen, bce, deblen, deb, bcdlen, bcd, ax, ay, az, adet), adet,
+        liftexact(dealen, dea, cdalen, cda, eaclen, eac, cdelen, cde, bx, by, bz, bdet), bdet,
+        sum_three(
+            liftexact(eablen, eab, deblen, deb, abdlen, abd, dealen, dea, cx, cy, cz, cdet), cdet,
+            liftexact(abclen, abc, eaclen, eac, bcelen, bce, eablen, eab, dx, dy, dz, ddet), ddet,
+            liftexact(bcdlen, bcd, abdlen, abd, cdalen, cda, abclen, abc, ex, ey, ez, edet), edet, cddet, cdedet), cdedet, abdet, deter);
+
+    return deter[deterlen - 1];
+}
+
+const xdet = vec(96);
+const ydet = vec(96);
+const zdet = vec(96);
+const fin = vec(1152);
+
+function liftadapt(a, b, c, az, bz, cz, x, y, z, out) {
+    const len = sum_three_scale(a, b, c, az, bz, cz, _24);
+    return sum_three(
+        scale(scale(len, _24, x, _48), _48, x, xdet), xdet,
+        scale(scale(len, _24, y, _48), _48, y, ydet), ydet,
+        scale(scale(len, _24, z, _48), _48, z, zdet), zdet, _192, out);
+}
+
+function insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez, permanent) {
+    let ab3, bc3, cd3, da3, ac3, bd3;
+
+    let aextail, bextail, cextail, dextail;
+    let aeytail, beytail, ceytail, deytail;
+    let aeztail, beztail, ceztail, deztail;
+
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0;
+
+    const aex = ax - ex;
+    const bex = bx - ex;
+    const cex = cx - ex;
+    const dex = dx - ex;
+    const aey = ay - ey;
+    const bey = by - ey;
+    const cey = cy - ey;
+    const dey = dy - ey;
+    const aez = az - ez;
+    const bez = bz - ez;
+    const cez = cz - ez;
+    const dez = dz - ez;
+
+    s1 = aex * bey;
+    c = splitter * aex;
+    ahi = c - (c - aex);
+    alo = aex - ahi;
+    c = splitter * bey;
+    bhi = c - (c - bey);
+    blo = bey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bex * aey;
+    c = splitter * bex;
+    ahi = c - (c - bex);
+    alo = bex - ahi;
+    c = splitter * aey;
+    bhi = c - (c - aey);
+    blo = aey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    ab3 = _j + _i;
+    bvirt = ab3 - _j;
+    ab[2] = _j - (ab3 - bvirt) + (_i - bvirt);
+    ab[3] = ab3;
+    s1 = bex * cey;
+    c = splitter * bex;
+    ahi = c - (c - bex);
+    alo = bex - ahi;
+    c = splitter * cey;
+    bhi = c - (c - cey);
+    blo = cey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cex * bey;
+    c = splitter * cex;
+    ahi = c - (c - cex);
+    alo = cex - ahi;
+    c = splitter * bey;
+    bhi = c - (c - bey);
+    blo = bey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    bc3 = _j + _i;
+    bvirt = bc3 - _j;
+    bc[2] = _j - (bc3 - bvirt) + (_i - bvirt);
+    bc[3] = bc3;
+    s1 = cex * dey;
+    c = splitter * cex;
+    ahi = c - (c - cex);
+    alo = cex - ahi;
+    c = splitter * dey;
+    bhi = c - (c - dey);
+    blo = dey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = dex * cey;
+    c = splitter * dex;
+    ahi = c - (c - dex);
+    alo = dex - ahi;
+    c = splitter * cey;
+    bhi = c - (c - cey);
+    blo = cey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    cd[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    cd[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    cd3 = _j + _i;
+    bvirt = cd3 - _j;
+    cd[2] = _j - (cd3 - bvirt) + (_i - bvirt);
+    cd[3] = cd3;
+    s1 = dex * aey;
+    c = splitter * dex;
+    ahi = c - (c - dex);
+    alo = dex - ahi;
+    c = splitter * aey;
+    bhi = c - (c - aey);
+    blo = aey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = aex * dey;
+    c = splitter * aex;
+    ahi = c - (c - aex);
+    alo = aex - ahi;
+    c = splitter * dey;
+    bhi = c - (c - dey);
+    blo = dey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    da[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    da[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    da3 = _j + _i;
+    bvirt = da3 - _j;
+    da[2] = _j - (da3 - bvirt) + (_i - bvirt);
+    da[3] = da3;
+    s1 = aex * cey;
+    c = splitter * aex;
+    ahi = c - (c - aex);
+    alo = aex - ahi;
+    c = splitter * cey;
+    bhi = c - (c - cey);
+    blo = cey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cex * aey;
+    c = splitter * cex;
+    ahi = c - (c - cex);
+    alo = cex - ahi;
+    c = splitter * aey;
+    bhi = c - (c - aey);
+    blo = aey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ac[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ac[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    ac3 = _j + _i;
+    bvirt = ac3 - _j;
+    ac[2] = _j - (ac3 - bvirt) + (_i - bvirt);
+    ac[3] = ac3;
+    s1 = bex * dey;
+    c = splitter * bex;
+    ahi = c - (c - bex);
+    alo = bex - ahi;
+    c = splitter * dey;
+    bhi = c - (c - dey);
+    blo = dey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = dex * bey;
+    c = splitter * dex;
+    ahi = c - (c - dex);
+    alo = dex - ahi;
+    c = splitter * bey;
+    bhi = c - (c - bey);
+    blo = bey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bd[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bd[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    bd3 = _j + _i;
+    bvirt = bd3 - _j;
+    bd[2] = _j - (bd3 - bvirt) + (_i - bvirt);
+    bd[3] = bd3;
+
+    const finlen = sum(
+        sum(
+            negate(liftadapt(bc, cd, bd, dez, bez, -cez, aex, aey, aez, adet), adet), adet,
+            liftadapt(cd, da, ac, aez, cez, dez, bex, bey, bez, bdet), bdet, abdet), abdet,
+        sum(
+            negate(liftadapt(da, ab, bd, bez, dez, aez, cex, cey, cez, cdet), cdet), cdet,
+            liftadapt(ab, bc, ac, cez, aez, -bez, dex, dey, dez, ddet), ddet, cddet), cddet, fin);
+
+    let det = estimate(finlen, fin);
+    let errbound = isperrboundB * permanent;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - aex;
+    aextail = ax - (aex + bvirt) + (bvirt - ex);
+    bvirt = ay - aey;
+    aeytail = ay - (aey + bvirt) + (bvirt - ey);
+    bvirt = az - aez;
+    aeztail = az - (aez + bvirt) + (bvirt - ez);
+    bvirt = bx - bex;
+    bextail = bx - (bex + bvirt) + (bvirt - ex);
+    bvirt = by - bey;
+    beytail = by - (bey + bvirt) + (bvirt - ey);
+    bvirt = bz - bez;
+    beztail = bz - (bez + bvirt) + (bvirt - ez);
+    bvirt = cx - cex;
+    cextail = cx - (cex + bvirt) + (bvirt - ex);
+    bvirt = cy - cey;
+    ceytail = cy - (cey + bvirt) + (bvirt - ey);
+    bvirt = cz - cez;
+    ceztail = cz - (cez + bvirt) + (bvirt - ez);
+    bvirt = dx - dex;
+    dextail = dx - (dex + bvirt) + (bvirt - ex);
+    bvirt = dy - dey;
+    deytail = dy - (dey + bvirt) + (bvirt - ey);
+    bvirt = dz - dez;
+    deztail = dz - (dez + bvirt) + (bvirt - ez);
+    if (aextail === 0 && aeytail === 0 && aeztail === 0 &&
+        bextail === 0 && beytail === 0 && beztail === 0 &&
+        cextail === 0 && ceytail === 0 && ceztail === 0 &&
+        dextail === 0 && deytail === 0 && deztail === 0) {
+        return det;
+    }
+
+    errbound = isperrboundC * permanent + resulterrbound * Math.abs(det);
+
+    const abeps = (aex * beytail + bey * aextail) - (aey * bextail + bex * aeytail);
+    const bceps = (bex * ceytail + cey * bextail) - (bey * cextail + cex * beytail);
+    const cdeps = (cex * deytail + dey * cextail) - (cey * dextail + dex * ceytail);
+    const daeps = (dex * aeytail + aey * dextail) - (dey * aextail + aex * deytail);
+    const aceps = (aex * ceytail + cey * aextail) - (aey * cextail + cex * aeytail);
+    const bdeps = (bex * deytail + dey * bextail) - (bey * dextail + dex * beytail);
+    det +=
+        (((bex * bex + bey * bey + bez * bez) * ((cez * daeps + dez * aceps + aez * cdeps) +
+        (ceztail * da3 + deztail * ac3 + aeztail * cd3)) + (dex * dex + dey * dey + dez * dez) *
+        ((aez * bceps - bez * aceps + cez * abeps) + (aeztail * bc3 - beztail * ac3 + ceztail * ab3))) -
+        ((aex * aex + aey * aey + aez * aez) * ((bez * cdeps - cez * bdeps + dez * bceps) +
+        (beztail * cd3 - ceztail * bd3 + deztail * bc3)) + (cex * cex + cey * cey + cez * cez) *
+        ((dez * abeps + aez * bdeps + bez * daeps) + (deztail * ab3 + aeztail * bd3 + beztail * da3)))) +
+        2 * (((bex * bextail + bey * beytail + bez * beztail) * (cez * da3 + dez * ac3 + aez * cd3) +
+        (dex * dextail + dey * deytail + dez * deztail) * (aez * bc3 - bez * ac3 + cez * ab3)) -
+        ((aex * aextail + aey * aeytail + aez * aeztail) * (bez * cd3 - cez * bd3 + dez * bc3) +
+        (cex * cextail + cey * ceytail + cez * ceztail) * (dez * ab3 + aez * bd3 + bez * da3)));
+
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    return insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez);
+}
+
+export function insphere(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {
+    const aex = ax - ex;
+    const bex = bx - ex;
+    const cex = cx - ex;
+    const dex = dx - ex;
+    const aey = ay - ey;
+    const bey = by - ey;
+    const cey = cy - ey;
+    const dey = dy - ey;
+    const aez = az - ez;
+    const bez = bz - ez;
+    const cez = cz - ez;
+    const dez = dz - ez;
+
+    const aexbey = aex * bey;
+    const bexaey = bex * aey;
+    const ab = aexbey - bexaey;
+    const bexcey = bex * cey;
+    const cexbey = cex * bey;
+    const bc = bexcey - cexbey;
+    const cexdey = cex * dey;
+    const dexcey = dex * cey;
+    const cd = cexdey - dexcey;
+    const dexaey = dex * aey;
+    const aexdey = aex * dey;
+    const da = dexaey - aexdey;
+    const aexcey = aex * cey;
+    const cexaey = cex * aey;
+    const ac = aexcey - cexaey;
+    const bexdey = bex * dey;
+    const dexbey = dex * bey;
+    const bd = bexdey - dexbey;
+
+    const alift = aex * aex + aey * aey + aez * aez;
+    const blift = bex * bex + bey * bey + bez * bez;
+    const clift = cex * cex + cey * cey + cez * cez;
+    const dlift = dex * dex + dey * dey + dez * dez;
+
+    const det =
+        (clift * (dez * ab + aez * bd + bez * da) - dlift * (aez * bc - bez * ac + cez * ab)) +
+        (alift * (bez * cd - cez * bd + dez * bc) - blift * (cez * da + dez * ac + aez * cd));
+
+    const aezplus = Math.abs(aez);
+    const bezplus = Math.abs(bez);
+    const cezplus = Math.abs(cez);
+    const dezplus = Math.abs(dez);
+    const aexbeyplus = Math.abs(aexbey) + Math.abs(bexaey);
+    const bexceyplus = Math.abs(bexcey) + Math.abs(cexbey);
+    const cexdeyplus = Math.abs(cexdey) + Math.abs(dexcey);
+    const dexaeyplus = Math.abs(dexaey) + Math.abs(aexdey);
+    const aexceyplus = Math.abs(aexcey) + Math.abs(cexaey);
+    const bexdeyplus = Math.abs(bexdey) + Math.abs(dexbey);
+    const permanent =
+        (cexdeyplus * bezplus + bexdeyplus * cezplus + bexceyplus * dezplus) * alift +
+        (dexaeyplus * cezplus + aexceyplus * dezplus + cexdeyplus * aezplus) * blift +
+        (aexbeyplus * dezplus + bexdeyplus * aezplus + dexaeyplus * bezplus) * clift +
+        (bexceyplus * aezplus + aexceyplus * bezplus + aexbeyplus * cezplus) * dlift;
+
+    const errbound = isperrboundA * permanent;
+    if (det > errbound || -det > errbound) {
+        return det;
+    }
+    return -insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez, permanent);
+}
+
+export function inspherefast(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {
+    const aex = ax - ex;
+    const bex = bx - ex;
+    const cex = cx - ex;
+    const dex = dx - ex;
+    const aey = ay - ey;
+    const bey = by - ey;
+    const cey = cy - ey;
+    const dey = dy - ey;
+    const aez = az - ez;
+    const bez = bz - ez;
+    const cez = cz - ez;
+    const dez = dz - ez;
+
+    const ab = aex * bey - bex * aey;
+    const bc = bex * cey - cex * bey;
+    const cd = cex * dey - dex * cey;
+    const da = dex * aey - aex * dey;
+    const ac = aex * cey - cex * aey;
+    const bd = bex * dey - dex * bey;
+
+    const abc = aez * bc - bez * ac + cez * ab;
+    const bcd = bez * cd - cez * bd + dez * bc;
+    const cda = cez * da + dez * ac + aez * cd;
+    const dab = dez * ab + aez * bd + bez * da;
+
+    const alift = aex * aex + aey * aey + aez * aez;
+    const blift = bex * bex + bey * bey + bez * bez;
+    const clift = cex * cex + cey * cey + cez * cez;
+    const dlift = dex * dex + dey * dey + dez * dez;
+
+    return (clift * dab - dlift * abc) + (alift * bcd - blift * cda);
+}
diff --git a/tools/ui/node_modules/robust-predicates/esm/orient2d.js b/tools/ui/node_modules/robust-predicates/esm/orient2d.js
new file mode 100644
index 0000000000000000000000000000000000000000..ae96c55160a86457b4b82c0198ca94220958ab94
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/esm/orient2d.js
@@ -0,0 +1,184 @@
+import {epsilon, splitter, resulterrbound, estimate, vec, sum} from './util.js';
+
+const ccwerrboundA = (3 + 16 * epsilon) * epsilon;
+const ccwerrboundB = (2 + 12 * epsilon) * epsilon;
+const ccwerrboundC = (9 + 64 * epsilon) * epsilon * epsilon;
+
+const B = vec(4);
+const C1 = vec(8);
+const C2 = vec(12);
+const D = vec(16);
+const u = vec(4);
+
+function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
+    let acxtail, acytail, bcxtail, bcytail;
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    const acx = ax - cx;
+    const bcx = bx - cx;
+    const acy = ay - cy;
+    const bcy = by - cy;
+
+    s1 = acx * bcy;
+    c = splitter * acx;
+    ahi = c - (c - acx);
+    alo = acx - ahi;
+    c = splitter * bcy;
+    bhi = c - (c - bcy);
+    blo = bcy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acy * bcx;
+    c = splitter * acy;
+    ahi = c - (c - acy);
+    alo = acy - ahi;
+    c = splitter * bcx;
+    bhi = c - (c - bcx);
+    blo = bcx - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    B[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    B[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    B[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    B[3] = u3;
+
+    let det = estimate(4, B);
+    let errbound = ccwerrboundB * detsum;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - acx;
+    acxtail = ax - (acx + bvirt) + (bvirt - cx);
+    bvirt = bx - bcx;
+    bcxtail = bx - (bcx + bvirt) + (bvirt - cx);
+    bvirt = ay - acy;
+    acytail = ay - (acy + bvirt) + (bvirt - cy);
+    bvirt = by - bcy;
+    bcytail = by - (bcy + bvirt) + (bvirt - cy);
+
+    if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) {
+        return det;
+    }
+
+    errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);
+    det += (acx * bcytail + bcy * acxtail) - (acy * bcxtail + bcx * acytail);
+    if (det >= errbound || -det >= errbound) return det;
+
+    s1 = acxtail * bcy;
+    c = splitter * acxtail;
+    ahi = c - (c - acxtail);
+    alo = acxtail - ahi;
+    c = splitter * bcy;
+    bhi = c - (c - bcy);
+    blo = bcy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acytail * bcx;
+    c = splitter * acytail;
+    ahi = c - (c - acytail);
+    alo = acytail - ahi;
+    c = splitter * bcx;
+    bhi = c - (c - bcx);
+    blo = bcx - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u[3] = u3;
+    const C1len = sum(4, B, 4, u, C1);
+
+    s1 = acx * bcytail;
+    c = splitter * acx;
+    ahi = c - (c - acx);
+    alo = acx - ahi;
+    c = splitter * bcytail;
+    bhi = c - (c - bcytail);
+    blo = bcytail - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acy * bcxtail;
+    c = splitter * acy;
+    ahi = c - (c - acy);
+    alo = acy - ahi;
+    c = splitter * bcxtail;
+    bhi = c - (c - bcxtail);
+    blo = bcxtail - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u[3] = u3;
+    const C2len = sum(C1len, C1, 4, u, C2);
+
+    s1 = acxtail * bcytail;
+    c = splitter * acxtail;
+    ahi = c - (c - acxtail);
+    alo = acxtail - ahi;
+    c = splitter * bcytail;
+    bhi = c - (c - bcytail);
+    blo = bcytail - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acytail * bcxtail;
+    c = splitter * acytail;
+    ahi = c - (c - acytail);
+    alo = acytail - ahi;
+    c = splitter * bcxtail;
+    bhi = c - (c - bcxtail);
+    blo = bcxtail - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u[3] = u3;
+    const Dlen = sum(C2len, C2, 4, u, D);
+
+    return D[Dlen - 1];
+}
+
+export function orient2d(ax, ay, bx, by, cx, cy) {
+    const detleft = (ay - cy) * (bx - cx);
+    const detright = (ax - cx) * (by - cy);
+    const det = detleft - detright;
+
+    const detsum = Math.abs(detleft + detright);
+    if (Math.abs(det) >= ccwerrboundA * detsum) return det;
+
+    return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum);
+}
+
+export function orient2dfast(ax, ay, bx, by, cx, cy) {
+    return (ay - cy) * (bx - cx) - (ax - cx) * (by - cy);
+}
diff --git a/tools/ui/node_modules/robust-predicates/esm/orient3d.js b/tools/ui/node_modules/robust-predicates/esm/orient3d.js
new file mode 100644
index 0000000000000000000000000000000000000000..2437cb3d30331f6f8016996575e46c561f4ca606
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/esm/orient3d.js
@@ -0,0 +1,459 @@
+import {epsilon, splitter, resulterrbound, estimate, vec, sum, scale} from './util.js';
+
+const o3derrboundA = (7 + 56 * epsilon) * epsilon;
+const o3derrboundB = (3 + 28 * epsilon) * epsilon;
+const o3derrboundC = (26 + 288 * epsilon) * epsilon * epsilon;
+
+const bc = vec(4);
+const ca = vec(4);
+const ab = vec(4);
+const at_b = vec(4);
+const at_c = vec(4);
+const bt_c = vec(4);
+const bt_a = vec(4);
+const ct_a = vec(4);
+const ct_b = vec(4);
+const bct = vec(8);
+const cat = vec(8);
+const abt = vec(8);
+const u = vec(4);
+
+const _8 = vec(8);
+const _8b = vec(8);
+const _16 = vec(16);
+const _12 = vec(12);
+
+let fin = vec(192);
+let fin2 = vec(192);
+
+function finadd(finlen, alen, a) {
+    finlen = sum(finlen, fin, alen, a, fin2);
+    const tmp = fin; fin = fin2; fin2 = tmp;
+    return finlen;
+}
+
+function tailinit(xtail, ytail, ax, ay, bx, by, a, b) {
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, t1, t0, u3, negate;
+    if (xtail === 0) {
+        if (ytail === 0) {
+            a[0] = 0;
+            b[0] = 0;
+            return 1;
+        }
+        negate = -ytail;
+        s1 = negate * ax;
+        c = splitter * negate;
+        ahi = c - (c - negate);
+        alo = negate - ahi;
+        c = splitter * ax;
+        bhi = c - (c - ax);
+        blo = ax - bhi;
+        a[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+        a[1] = s1;
+        s1 = ytail * bx;
+        c = splitter * ytail;
+        ahi = c - (c - ytail);
+        alo = ytail - ahi;
+        c = splitter * bx;
+        bhi = c - (c - bx);
+        blo = bx - bhi;
+        b[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+        b[1] = s1;
+        return 2;
+    }
+    if (ytail === 0) {
+        s1 = xtail * ay;
+        c = splitter * xtail;
+        ahi = c - (c - xtail);
+        alo = xtail - ahi;
+        c = splitter * ay;
+        bhi = c - (c - ay);
+        blo = ay - bhi;
+        a[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+        a[1] = s1;
+        negate = -xtail;
+        s1 = negate * by;
+        c = splitter * negate;
+        ahi = c - (c - negate);
+        alo = negate - ahi;
+        c = splitter * by;
+        bhi = c - (c - by);
+        blo = by - bhi;
+        b[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+        b[1] = s1;
+        return 2;
+    }
+    s1 = xtail * ay;
+    c = splitter * xtail;
+    ahi = c - (c - xtail);
+    alo = xtail - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ytail * ax;
+    c = splitter * ytail;
+    ahi = c - (c - ytail);
+    alo = ytail - ahi;
+    c = splitter * ax;
+    bhi = c - (c - ax);
+    blo = ax - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    a[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    a[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    a[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    a[3] = u3;
+    s1 = ytail * bx;
+    c = splitter * ytail;
+    ahi = c - (c - ytail);
+    alo = ytail - ahi;
+    c = splitter * bx;
+    bhi = c - (c - bx);
+    blo = bx - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = xtail * by;
+    c = splitter * xtail;
+    ahi = c - (c - xtail);
+    alo = xtail - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    b[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    b[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    b[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    b[3] = u3;
+    return 4;
+}
+
+function tailadd(finlen, a, b, k, z) {
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, u3;
+    s1 = a * b;
+    c = splitter * a;
+    ahi = c - (c - a);
+    alo = a - ahi;
+    c = splitter * b;
+    bhi = c - (c - b);
+    blo = b - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    c = splitter * k;
+    bhi = c - (c - k);
+    blo = k - bhi;
+    _i = s0 * k;
+    c = splitter * s0;
+    ahi = c - (c - s0);
+    alo = s0 - ahi;
+    u[0] = alo * blo - (_i - ahi * bhi - alo * bhi - ahi * blo);
+    _j = s1 * k;
+    c = splitter * s1;
+    ahi = c - (c - s1);
+    alo = s1 - ahi;
+    _0 = alo * blo - (_j - ahi * bhi - alo * bhi - ahi * blo);
+    _k = _i + _0;
+    bvirt = _k - _i;
+    u[1] = _i - (_k - bvirt) + (_0 - bvirt);
+    u3 = _j + _k;
+    u[2] = _k - (u3 - _j);
+    u[3] = u3;
+    finlen = finadd(finlen, 4, u);
+    if (z !== 0) {
+        c = splitter * z;
+        bhi = c - (c - z);
+        blo = z - bhi;
+        _i = s0 * z;
+        c = splitter * s0;
+        ahi = c - (c - s0);
+        alo = s0 - ahi;
+        u[0] = alo * blo - (_i - ahi * bhi - alo * bhi - ahi * blo);
+        _j = s1 * z;
+        c = splitter * s1;
+        ahi = c - (c - s1);
+        alo = s1 - ahi;
+        _0 = alo * blo - (_j - ahi * bhi - alo * bhi - ahi * blo);
+        _k = _i + _0;
+        bvirt = _k - _i;
+        u[1] = _i - (_k - bvirt) + (_0 - bvirt);
+        u3 = _j + _k;
+        u[2] = _k - (u3 - _j);
+        u[3] = u3;
+        finlen = finadd(finlen, 4, u);
+    }
+    return finlen;
+}
+
+function orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent) {
+    let finlen;
+    let adxtail, bdxtail, cdxtail;
+    let adytail, bdytail, cdytail;
+    let adztail, bdztail, cdztail;
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, t1, t0, u3;
+
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+    const adz = az - dz;
+    const bdz = bz - dz;
+    const cdz = cz - dz;
+
+    s1 = bdx * cdy;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cdx * bdy;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bc[3] = u3;
+    s1 = cdx * ady;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = adx * cdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ca[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ca[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ca[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ca[3] = u3;
+    s1 = adx * bdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bdx * ady;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ab[3] = u3;
+
+    finlen = sum(
+        sum(
+            scale(4, bc, adz, _8), _8,
+            scale(4, ca, bdz, _8b), _8b, _16), _16,
+        scale(4, ab, cdz, _8), _8, fin);
+
+    let det = estimate(finlen, fin);
+    let errbound = o3derrboundB * permanent;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - adx;
+    adxtail = ax - (adx + bvirt) + (bvirt - dx);
+    bvirt = bx - bdx;
+    bdxtail = bx - (bdx + bvirt) + (bvirt - dx);
+    bvirt = cx - cdx;
+    cdxtail = cx - (cdx + bvirt) + (bvirt - dx);
+    bvirt = ay - ady;
+    adytail = ay - (ady + bvirt) + (bvirt - dy);
+    bvirt = by - bdy;
+    bdytail = by - (bdy + bvirt) + (bvirt - dy);
+    bvirt = cy - cdy;
+    cdytail = cy - (cdy + bvirt) + (bvirt - dy);
+    bvirt = az - adz;
+    adztail = az - (adz + bvirt) + (bvirt - dz);
+    bvirt = bz - bdz;
+    bdztail = bz - (bdz + bvirt) + (bvirt - dz);
+    bvirt = cz - cdz;
+    cdztail = cz - (cdz + bvirt) + (bvirt - dz);
+
+    if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 &&
+        adytail === 0 && bdytail === 0 && cdytail === 0 &&
+        adztail === 0 && bdztail === 0 && cdztail === 0) {
+        return det;
+    }
+
+    errbound = o3derrboundC * permanent + resulterrbound * Math.abs(det);
+    det +=
+        adz * (bdx * cdytail + cdy * bdxtail - (bdy * cdxtail + cdx * bdytail)) + adztail * (bdx * cdy - bdy * cdx) +
+        bdz * (cdx * adytail + ady * cdxtail - (cdy * adxtail + adx * cdytail)) + bdztail * (cdx * ady - cdy * adx) +
+        cdz * (adx * bdytail + bdy * adxtail - (ady * bdxtail + bdx * adytail)) + cdztail * (adx * bdy - ady * bdx);
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    const at_len = tailinit(adxtail, adytail, bdx, bdy, cdx, cdy, at_b, at_c);
+    const bt_len = tailinit(bdxtail, bdytail, cdx, cdy, adx, ady, bt_c, bt_a);
+    const ct_len = tailinit(cdxtail, cdytail, adx, ady, bdx, bdy, ct_a, ct_b);
+
+    const bctlen = sum(bt_len, bt_c, ct_len, ct_b, bct);
+    finlen = finadd(finlen, scale(bctlen, bct, adz, _16), _16);
+
+    const catlen = sum(ct_len, ct_a, at_len, at_c, cat);
+    finlen = finadd(finlen, scale(catlen, cat, bdz, _16), _16);
+
+    const abtlen = sum(at_len, at_b, bt_len, bt_a, abt);
+    finlen = finadd(finlen, scale(abtlen, abt, cdz, _16), _16);
+
+    if (adztail !== 0) {
+        finlen = finadd(finlen, scale(4, bc, adztail, _12), _12);
+        finlen = finadd(finlen, scale(bctlen, bct, adztail, _16), _16);
+    }
+    if (bdztail !== 0) {
+        finlen = finadd(finlen, scale(4, ca, bdztail, _12), _12);
+        finlen = finadd(finlen, scale(catlen, cat, bdztail, _16), _16);
+    }
+    if (cdztail !== 0) {
+        finlen = finadd(finlen, scale(4, ab, cdztail, _12), _12);
+        finlen = finadd(finlen, scale(abtlen, abt, cdztail, _16), _16);
+    }
+
+    if (adxtail !== 0) {
+        if (bdytail !== 0) {
+            finlen = tailadd(finlen, adxtail, bdytail, cdz, cdztail);
+        }
+        if (cdytail !== 0) {
+            finlen = tailadd(finlen, -adxtail, cdytail, bdz, bdztail);
+        }
+    }
+    if (bdxtail !== 0) {
+        if (cdytail !== 0) {
+            finlen = tailadd(finlen, bdxtail, cdytail, adz, adztail);
+        }
+        if (adytail !== 0) {
+            finlen = tailadd(finlen, -bdxtail, adytail, cdz, cdztail);
+        }
+    }
+    if (cdxtail !== 0) {
+        if (adytail !== 0) {
+            finlen = tailadd(finlen, cdxtail, adytail, bdz, bdztail);
+        }
+        if (bdytail !== 0) {
+            finlen = tailadd(finlen, -cdxtail, bdytail, adz, adztail);
+        }
+    }
+
+    return fin[finlen - 1];
+}
+
+export function orient3d(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+    const adz = az - dz;
+    const bdz = bz - dz;
+    const cdz = cz - dz;
+
+    const bdxcdy = bdx * cdy;
+    const cdxbdy = cdx * bdy;
+
+    const cdxady = cdx * ady;
+    const adxcdy = adx * cdy;
+
+    const adxbdy = adx * bdy;
+    const bdxady = bdx * ady;
+
+    const det =
+        adz * (bdxcdy - cdxbdy) +
+        bdz * (cdxady - adxcdy) +
+        cdz * (adxbdy - bdxady);
+
+    const permanent =
+        (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * Math.abs(adz) +
+        (Math.abs(cdxady) + Math.abs(adxcdy)) * Math.abs(bdz) +
+        (Math.abs(adxbdy) + Math.abs(bdxady)) * Math.abs(cdz);
+
+    const errbound = o3derrboundA * permanent;
+    if (det > errbound || -det > errbound) {
+        return det;
+    }
+
+    return orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent);
+}
+
+export function orient3dfast(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+    const adz = az - dz;
+    const bdz = bz - dz;
+    const cdz = cz - dz;
+
+    return adx * (bdy * cdz - bdz * cdy) +
+        bdx * (cdy * adz - cdz * ady) +
+        cdx * (ady * bdz - adz * bdy);
+}
diff --git a/tools/ui/node_modules/robust-predicates/esm/util.js b/tools/ui/node_modules/robust-predicates/esm/util.js
new file mode 100644
index 0000000000000000000000000000000000000000..5e0ff7dcc6924af682a8e5ae86ff8798031f9983
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/esm/util.js
@@ -0,0 +1,138 @@
+export const epsilon = 1.1102230246251565e-16;
+export const splitter = 134217729;
+export const resulterrbound = (3 + 8 * epsilon) * epsilon;
+
+// fast_expansion_sum_zeroelim routine from original code
+export function sum(elen, e, flen, f, h) {
+    let Q, Qnew, hh, bvirt;
+    let enow = e[0];
+    let fnow = f[0];
+    let eindex = 0;
+    let findex = 0;
+    if ((fnow > enow) === (fnow > -enow)) {
+        Q = enow;
+        enow = e[++eindex];
+    } else {
+        Q = fnow;
+        fnow = f[++findex];
+    }
+    let hindex = 0;
+    if (eindex < elen && findex < flen) {
+        if ((fnow > enow) === (fnow > -enow)) {
+            Qnew = enow + Q;
+            hh = Q - (Qnew - enow);
+            enow = e[++eindex];
+        } else {
+            Qnew = fnow + Q;
+            hh = Q - (Qnew - fnow);
+            fnow = f[++findex];
+        }
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        while (eindex < elen && findex < flen) {
+            if ((fnow > enow) === (fnow > -enow)) {
+                Qnew = Q + enow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (enow - bvirt);
+                enow = e[++eindex];
+            } else {
+                Qnew = Q + fnow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+                fnow = f[++findex];
+            }
+            Q = Qnew;
+            if (hh !== 0) {
+                h[hindex++] = hh;
+            }
+        }
+    }
+    while (eindex < elen) {
+        Qnew = Q + enow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (enow - bvirt);
+        enow = e[++eindex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    while (findex < flen) {
+        Qnew = Q + fnow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+        fnow = f[++findex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+export function sum_three(alen, a, blen, b, clen, c, tmp, out) {
+    return sum(sum(alen, a, blen, b, tmp), tmp, clen, c, out);
+}
+
+// scale_expansion_zeroelim routine from oritinal code
+export function scale(elen, e, b, h) {
+    let Q, sum, hh, product1, product0;
+    let bvirt, c, ahi, alo, bhi, blo;
+
+    c = splitter * b;
+    bhi = c - (c - b);
+    blo = b - bhi;
+    let enow = e[0];
+    Q = enow * b;
+    c = splitter * enow;
+    ahi = c - (c - enow);
+    alo = enow - ahi;
+    hh = alo * blo - (Q - ahi * bhi - alo * bhi - ahi * blo);
+    let hindex = 0;
+    if (hh !== 0) {
+        h[hindex++] = hh;
+    }
+    for (let i = 1; i < elen; i++) {
+        enow = e[i];
+        product1 = enow * b;
+        c = splitter * enow;
+        ahi = c - (c - enow);
+        alo = enow - ahi;
+        product0 = alo * blo - (product1 - ahi * bhi - alo * bhi - ahi * blo);
+        sum = Q + product0;
+        bvirt = sum - Q;
+        hh = Q - (sum - bvirt) + (product0 - bvirt);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        Q = product1 + sum;
+        hh = sum - (Q - product1);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+export function negate(elen, e) {
+    for (let i = 0; i < elen; i++) e[i] = -e[i];
+    return elen;
+}
+
+export function estimate(elen, e) {
+    let Q = e[0];
+    for (let i = 1; i < elen; i++) Q += e[i];
+    return Q;
+}
+
+export function vec(n) {
+    return new Float64Array(n);
+}
diff --git a/tools/ui/node_modules/robust-predicates/index.d.ts b/tools/ui/node_modules/robust-predicates/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c233a43fee1e3026832a054ec5d2aec5b5360ac8
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/index.d.ts
@@ -0,0 +1,49 @@
+export as namespace predicates;
+
+export function orient2d(
+    ax: number, ay: number,
+    bx: number, by: number,
+    cx: number, cy: number): number;
+
+export function orient2dfast(
+    ax: number, ay: number,
+    bx: number, by: number,
+    cx: number, cy: number): number;
+
+export function incircle(
+    ax: number, ay: number,
+    bx: number, by: number,
+    cx: number, cy: number,
+    dx: number, dy: number): number;
+
+export function incirclefast(
+    ax: number, ay: number,
+    bx: number, by: number,
+    cx: number, cy: number,
+    dx: number, dy: number): number;
+
+export function orient3d(
+    ax: number, ay: number, az: number,
+    bx: number, by: number, bz: number,
+    cx: number, cy: number, cz: number,
+    dx: number, dy: number, dz: number): number;
+
+export function orient3dfast(
+    ax: number, ay: number, az: number,
+    bx: number, by: number, bz: number,
+    cx: number, cy: number, cz: number,
+    dx: number, dy: number, dz: number): number;
+
+export function insphere(
+    ax: number, ay: number, az: number,
+    bx: number, by: number, bz: number,
+    cx: number, cy: number, cz: number,
+    dx: number, dy: number, dz: number,
+    ex: number, ey: number, ez: number): number;
+
+export function inspherefast(
+    ax: number, ay: number, az: number,
+    bx: number, by: number, bz: number,
+    cx: number, cy: number, cz: number,
+    dx: number, dy: number, dz: number,
+    ex: number, ey: number, ez: number): number;
diff --git a/tools/ui/node_modules/robust-predicates/index.js b/tools/ui/node_modules/robust-predicates/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..db4764b6aa0766b73e5e910085e6d055797c80c7
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/index.js
@@ -0,0 +1,5 @@
+
+export {orient2d, orient2dfast} from './esm/orient2d.js';
+export {orient3d, orient3dfast} from './esm/orient3d.js';
+export {incircle, incirclefast} from './esm/incircle.js';
+export {insphere, inspherefast} from './esm/insphere.js';
diff --git a/tools/ui/node_modules/robust-predicates/package.json b/tools/ui/node_modules/robust-predicates/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..dfebad3c0b41b447bc8a951a8eb06819ee942b12
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/package.json
@@ -0,0 +1,45 @@
+{
+  "name": "robust-predicates",
+  "version": "3.0.3",
+  "description": "Fast robust predicates for computational geometry",
+  "keywords": [
+    "computational geometry",
+    "robust arithmetic"
+  ],
+  "author": "Vladimir Agafonkin",
+  "license": "Unlicense",
+  "type": "module",
+  "main": "index.js",
+  "unpkg": "umd/predicates.min.js",
+  "module": "index.js",
+  "exports": "./index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "mkdir -p esm && node compile.js",
+    "lint": "eslint *.js src test/test.js",
+    "pretest": "npm run lint && npm run build",
+    "test": "node --test",
+    "cov": "node --test --experimental-test-coverage",
+    "bench": "node bench.js",
+    "prepublishOnly": "npm run test && rollup -c"
+  },
+  "devDependencies": {
+    "@rollup/plugin-terser": "^1.0.0",
+    "eslint": "^10.1.0",
+    "eslint-config-mourner": "^4.1.0",
+    "nextafter": "^1.0.0",
+    "robust-in-sphere": "^1.2.1",
+    "robust-orientation": "^1.2.1",
+    "rollup": "^4.59.1"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "esm",
+    "umd"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mourner/robust-predicates.git"
+  }
+}
diff --git a/tools/ui/node_modules/robust-predicates/umd/incircle.js b/tools/ui/node_modules/robust-predicates/umd/incircle.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e33d33f54e537ac36b8a158cf13c52b7013e4dc
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/umd/incircle.js
@@ -0,0 +1,908 @@
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+typeof define === 'function' && define.amd ? define(['exports'], factory) :
+(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.predicates = {}));
+})(this, (function (exports) { 'use strict';
+
+const epsilon = 1.1102230246251565e-16;
+const splitter = 134217729;
+const resulterrbound = (3 + 8 * epsilon) * epsilon;
+
+// fast_expansion_sum_zeroelim routine from original code
+function sum(elen, e, flen, f, h) {
+    let Q, Qnew, hh, bvirt;
+    let enow = e[0];
+    let fnow = f[0];
+    let eindex = 0;
+    let findex = 0;
+    if ((fnow > enow) === (fnow > -enow)) {
+        Q = enow;
+        enow = e[++eindex];
+    } else {
+        Q = fnow;
+        fnow = f[++findex];
+    }
+    let hindex = 0;
+    if (eindex < elen && findex < flen) {
+        if ((fnow > enow) === (fnow > -enow)) {
+            Qnew = enow + Q;
+            hh = Q - (Qnew - enow);
+            enow = e[++eindex];
+        } else {
+            Qnew = fnow + Q;
+            hh = Q - (Qnew - fnow);
+            fnow = f[++findex];
+        }
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        while (eindex < elen && findex < flen) {
+            if ((fnow > enow) === (fnow > -enow)) {
+                Qnew = Q + enow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (enow - bvirt);
+                enow = e[++eindex];
+            } else {
+                Qnew = Q + fnow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+                fnow = f[++findex];
+            }
+            Q = Qnew;
+            if (hh !== 0) {
+                h[hindex++] = hh;
+            }
+        }
+    }
+    while (eindex < elen) {
+        Qnew = Q + enow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (enow - bvirt);
+        enow = e[++eindex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    while (findex < flen) {
+        Qnew = Q + fnow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+        fnow = f[++findex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+function sum_three(alen, a, blen, b, clen, c, tmp, out) {
+    return sum(sum(alen, a, blen, b, tmp), tmp, clen, c, out);
+}
+
+// scale_expansion_zeroelim routine from oritinal code
+function scale(elen, e, b, h) {
+    let Q, sum, hh, product1, product0;
+    let bvirt, c, ahi, alo, bhi, blo;
+
+    c = splitter * b;
+    bhi = c - (c - b);
+    blo = b - bhi;
+    let enow = e[0];
+    Q = enow * b;
+    c = splitter * enow;
+    ahi = c - (c - enow);
+    alo = enow - ahi;
+    hh = alo * blo - (Q - ahi * bhi - alo * bhi - ahi * blo);
+    let hindex = 0;
+    if (hh !== 0) {
+        h[hindex++] = hh;
+    }
+    for (let i = 1; i < elen; i++) {
+        enow = e[i];
+        product1 = enow * b;
+        c = splitter * enow;
+        ahi = c - (c - enow);
+        alo = enow - ahi;
+        product0 = alo * blo - (product1 - ahi * bhi - alo * bhi - ahi * blo);
+        sum = Q + product0;
+        bvirt = sum - Q;
+        hh = Q - (sum - bvirt) + (product0 - bvirt);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        Q = product1 + sum;
+        hh = sum - (Q - product1);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+function estimate(elen, e) {
+    let Q = e[0];
+    for (let i = 1; i < elen; i++) Q += e[i];
+    return Q;
+}
+
+function vec(n) {
+    return new Float64Array(n);
+}
+
+const iccerrboundA = (10 + 96 * epsilon) * epsilon;
+const iccerrboundB = (4 + 48 * epsilon) * epsilon;
+const iccerrboundC = (44 + 576 * epsilon) * epsilon * epsilon;
+
+const bc = vec(4);
+const ca = vec(4);
+const ab = vec(4);
+const aa = vec(4);
+const bb = vec(4);
+const cc = vec(4);
+const u = vec(4);
+const v = vec(4);
+const axtbc = vec(8);
+const aytbc = vec(8);
+const bxtca = vec(8);
+const bytca = vec(8);
+const cxtab = vec(8);
+const cytab = vec(8);
+const abt = vec(8);
+const bct = vec(8);
+const cat = vec(8);
+const abtt = vec(4);
+const bctt = vec(4);
+const catt = vec(4);
+
+const _8 = vec(8);
+const _16 = vec(16);
+const _16b = vec(16);
+const _16c = vec(16);
+const _32 = vec(32);
+const _32b = vec(32);
+const _48 = vec(48);
+const _64 = vec(64);
+
+let fin = vec(1152);
+let fin2 = vec(1152);
+
+function finadd(finlen, a, alen) {
+    finlen = sum(finlen, fin, a, alen, fin2);
+    const tmp = fin; fin = fin2; fin2 = tmp;
+    return finlen;
+}
+
+function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
+    let finlen;
+    let adxtail, bdxtail, cdxtail, adytail, bdytail, cdytail;
+    let axtbclen, aytbclen, bxtcalen, bytcalen, cxtablen, cytablen;
+    let abtlen, bctlen, catlen;
+    let abttlen, bcttlen, cattlen;
+    let n1, n0;
+
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+
+    s1 = bdx * cdy;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cdx * bdy;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bc[3] = u3;
+    s1 = cdx * ady;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = adx * cdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ca[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ca[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ca[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ca[3] = u3;
+    s1 = adx * bdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bdx * ady;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ab[3] = u3;
+
+    finlen = sum(
+        sum(
+            sum(
+                scale(scale(4, bc, adx, _8), _8, adx, _16), _16,
+                scale(scale(4, bc, ady, _8), _8, ady, _16b), _16b, _32), _32,
+            sum(
+                scale(scale(4, ca, bdx, _8), _8, bdx, _16), _16,
+                scale(scale(4, ca, bdy, _8), _8, bdy, _16b), _16b, _32b), _32b, _64), _64,
+        sum(
+            scale(scale(4, ab, cdx, _8), _8, cdx, _16), _16,
+            scale(scale(4, ab, cdy, _8), _8, cdy, _16b), _16b, _32), _32, fin);
+
+    let det = estimate(finlen, fin);
+    let errbound = iccerrboundB * permanent;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - adx;
+    adxtail = ax - (adx + bvirt) + (bvirt - dx);
+    bvirt = ay - ady;
+    adytail = ay - (ady + bvirt) + (bvirt - dy);
+    bvirt = bx - bdx;
+    bdxtail = bx - (bdx + bvirt) + (bvirt - dx);
+    bvirt = by - bdy;
+    bdytail = by - (bdy + bvirt) + (bvirt - dy);
+    bvirt = cx - cdx;
+    cdxtail = cx - (cdx + bvirt) + (bvirt - dx);
+    bvirt = cy - cdy;
+    cdytail = cy - (cdy + bvirt) + (bvirt - dy);
+    if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 && adytail === 0 && bdytail === 0 && cdytail === 0) {
+        return det;
+    }
+
+    errbound = iccerrboundC * permanent + resulterrbound * Math.abs(det);
+    det += ((adx * adx + ady * ady) * ((bdx * cdytail + cdy * bdxtail) - (bdy * cdxtail + cdx * bdytail)) +
+        2 * (adx * adxtail + ady * adytail) * (bdx * cdy - bdy * cdx)) +
+        ((bdx * bdx + bdy * bdy) * ((cdx * adytail + ady * cdxtail) - (cdy * adxtail + adx * cdytail)) +
+        2 * (bdx * bdxtail + bdy * bdytail) * (cdx * ady - cdy * adx)) +
+        ((cdx * cdx + cdy * cdy) * ((adx * bdytail + bdy * adxtail) - (ady * bdxtail + bdx * adytail)) +
+        2 * (cdx * cdxtail + cdy * cdytail) * (adx * bdy - ady * bdx));
+
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {
+        s1 = adx * adx;
+        c = splitter * adx;
+        ahi = c - (c - adx);
+        alo = adx - ahi;
+        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
+        t1 = ady * ady;
+        c = splitter * ady;
+        ahi = c - (c - ady);
+        alo = ady - ahi;
+        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
+        _i = s0 + t0;
+        bvirt = _i - s0;
+        aa[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        aa[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        aa[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        aa[3] = u3;
+    }
+    if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {
+        s1 = bdx * bdx;
+        c = splitter * bdx;
+        ahi = c - (c - bdx);
+        alo = bdx - ahi;
+        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
+        t1 = bdy * bdy;
+        c = splitter * bdy;
+        ahi = c - (c - bdy);
+        alo = bdy - ahi;
+        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
+        _i = s0 + t0;
+        bvirt = _i - s0;
+        bb[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        bb[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        bb[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        bb[3] = u3;
+    }
+    if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {
+        s1 = cdx * cdx;
+        c = splitter * cdx;
+        ahi = c - (c - cdx);
+        alo = cdx - ahi;
+        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
+        t1 = cdy * cdy;
+        c = splitter * cdy;
+        ahi = c - (c - cdy);
+        alo = cdy - ahi;
+        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
+        _i = s0 + t0;
+        bvirt = _i - s0;
+        cc[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        cc[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        cc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        cc[3] = u3;
+    }
+
+    if (adxtail !== 0) {
+        axtbclen = scale(4, bc, adxtail, axtbc);
+        finlen = finadd(finlen, sum_three(
+            scale(axtbclen, axtbc, 2 * adx, _16), _16,
+            scale(scale(4, cc, adxtail, _8), _8, bdy, _16b), _16b,
+            scale(scale(4, bb, adxtail, _8), _8, -cdy, _16c), _16c, _32, _48), _48);
+    }
+    if (adytail !== 0) {
+        aytbclen = scale(4, bc, adytail, aytbc);
+        finlen = finadd(finlen, sum_three(
+            scale(aytbclen, aytbc, 2 * ady, _16), _16,
+            scale(scale(4, bb, adytail, _8), _8, cdx, _16b), _16b,
+            scale(scale(4, cc, adytail, _8), _8, -bdx, _16c), _16c, _32, _48), _48);
+    }
+    if (bdxtail !== 0) {
+        bxtcalen = scale(4, ca, bdxtail, bxtca);
+        finlen = finadd(finlen, sum_three(
+            scale(bxtcalen, bxtca, 2 * bdx, _16), _16,
+            scale(scale(4, aa, bdxtail, _8), _8, cdy, _16b), _16b,
+            scale(scale(4, cc, bdxtail, _8), _8, -ady, _16c), _16c, _32, _48), _48);
+    }
+    if (bdytail !== 0) {
+        bytcalen = scale(4, ca, bdytail, bytca);
+        finlen = finadd(finlen, sum_three(
+            scale(bytcalen, bytca, 2 * bdy, _16), _16,
+            scale(scale(4, cc, bdytail, _8), _8, adx, _16b), _16b,
+            scale(scale(4, aa, bdytail, _8), _8, -cdx, _16c), _16c, _32, _48), _48);
+    }
+    if (cdxtail !== 0) {
+        cxtablen = scale(4, ab, cdxtail, cxtab);
+        finlen = finadd(finlen, sum_three(
+            scale(cxtablen, cxtab, 2 * cdx, _16), _16,
+            scale(scale(4, bb, cdxtail, _8), _8, ady, _16b), _16b,
+            scale(scale(4, aa, cdxtail, _8), _8, -bdy, _16c), _16c, _32, _48), _48);
+    }
+    if (cdytail !== 0) {
+        cytablen = scale(4, ab, cdytail, cytab);
+        finlen = finadd(finlen, sum_three(
+            scale(cytablen, cytab, 2 * cdy, _16), _16,
+            scale(scale(4, aa, cdytail, _8), _8, bdx, _16b), _16b,
+            scale(scale(4, bb, cdytail, _8), _8, -adx, _16c), _16c, _32, _48), _48);
+    }
+
+    if (adxtail !== 0 || adytail !== 0) {
+        if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {
+            s1 = bdxtail * cdy;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * cdy;
+            bhi = c - (c - cdy);
+            blo = cdy - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = bdx * cdytail;
+            c = splitter * bdx;
+            ahi = c - (c - bdx);
+            alo = bdx - ahi;
+            c = splitter * cdytail;
+            bhi = c - (c - cdytail);
+            blo = cdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
+            s1 = cdxtail * -bdy;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * -bdy;
+            bhi = c - (c - -bdy);
+            blo = -bdy - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdx * -bdytail;
+            c = splitter * cdx;
+            ahi = c - (c - cdx);
+            alo = cdx - ahi;
+            c = splitter * -bdytail;
+            bhi = c - (c - -bdytail);
+            blo = -bdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            v[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            v[3] = u3;
+            bctlen = sum(4, u, 4, v, bct);
+            s1 = bdxtail * cdytail;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * cdytail;
+            bhi = c - (c - cdytail);
+            blo = cdytail - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdxtail * bdytail;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * bdytail;
+            bhi = c - (c - bdytail);
+            blo = bdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 - t0;
+            bvirt = s0 - _i;
+            bctt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            bctt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            bctt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            bctt[3] = u3;
+            bcttlen = 4;
+        } else {
+            bct[0] = 0;
+            bctlen = 1;
+            bctt[0] = 0;
+            bcttlen = 1;
+        }
+        if (adxtail !== 0) {
+            const len = scale(bctlen, bct, adxtail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(axtbclen, axtbc, adxtail, _16), _16,
+                scale(len, _16c, 2 * adx, _32), _32, _48), _48);
+
+            const len2 = scale(bcttlen, bctt, adxtail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * adx, _16), _16,
+                scale(len2, _8, adxtail, _16b), _16b,
+                scale(len, _16c, adxtail, _32), _32, _32b, _64), _64);
+
+            if (bdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, cc, adxtail, _8), _8, bdytail, _16), _16);
+            }
+            if (cdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, bb, -adxtail, _8), _8, cdytail, _16), _16);
+            }
+        }
+        if (adytail !== 0) {
+            const len = scale(bctlen, bct, adytail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(aytbclen, aytbc, adytail, _16), _16,
+                scale(len, _16c, 2 * ady, _32), _32, _48), _48);
+
+            const len2 = scale(bcttlen, bctt, adytail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * ady, _16), _16,
+                scale(len2, _8, adytail, _16b), _16b,
+                scale(len, _16c, adytail, _32), _32, _32b, _64), _64);
+        }
+    }
+    if (bdxtail !== 0 || bdytail !== 0) {
+        if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {
+            s1 = cdxtail * ady;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * ady;
+            bhi = c - (c - ady);
+            blo = ady - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdx * adytail;
+            c = splitter * cdx;
+            ahi = c - (c - cdx);
+            alo = cdx - ahi;
+            c = splitter * adytail;
+            bhi = c - (c - adytail);
+            blo = adytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
+            n1 = -cdy;
+            n0 = -cdytail;
+            s1 = adxtail * n1;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * n1;
+            bhi = c - (c - n1);
+            blo = n1 - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = adx * n0;
+            c = splitter * adx;
+            ahi = c - (c - adx);
+            alo = adx - ahi;
+            c = splitter * n0;
+            bhi = c - (c - n0);
+            blo = n0 - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            v[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            v[3] = u3;
+            catlen = sum(4, u, 4, v, cat);
+            s1 = cdxtail * adytail;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * adytail;
+            bhi = c - (c - adytail);
+            blo = adytail - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = adxtail * cdytail;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * cdytail;
+            bhi = c - (c - cdytail);
+            blo = cdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 - t0;
+            bvirt = s0 - _i;
+            catt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            catt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            catt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            catt[3] = u3;
+            cattlen = 4;
+        } else {
+            cat[0] = 0;
+            catlen = 1;
+            catt[0] = 0;
+            cattlen = 1;
+        }
+        if (bdxtail !== 0) {
+            const len = scale(catlen, cat, bdxtail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(bxtcalen, bxtca, bdxtail, _16), _16,
+                scale(len, _16c, 2 * bdx, _32), _32, _48), _48);
+
+            const len2 = scale(cattlen, catt, bdxtail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * bdx, _16), _16,
+                scale(len2, _8, bdxtail, _16b), _16b,
+                scale(len, _16c, bdxtail, _32), _32, _32b, _64), _64);
+
+            if (cdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, aa, bdxtail, _8), _8, cdytail, _16), _16);
+            }
+            if (adytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, cc, -bdxtail, _8), _8, adytail, _16), _16);
+            }
+        }
+        if (bdytail !== 0) {
+            const len = scale(catlen, cat, bdytail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(bytcalen, bytca, bdytail, _16), _16,
+                scale(len, _16c, 2 * bdy, _32), _32, _48), _48);
+
+            const len2 = scale(cattlen, catt, bdytail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * bdy, _16), _16,
+                scale(len2, _8, bdytail, _16b), _16b,
+                scale(len, _16c, bdytail, _32), _32,  _32b, _64), _64);
+        }
+    }
+    if (cdxtail !== 0 || cdytail !== 0) {
+        if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {
+            s1 = adxtail * bdy;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * bdy;
+            bhi = c - (c - bdy);
+            blo = bdy - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = adx * bdytail;
+            c = splitter * adx;
+            ahi = c - (c - adx);
+            alo = adx - ahi;
+            c = splitter * bdytail;
+            bhi = c - (c - bdytail);
+            blo = bdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
+            n1 = -ady;
+            n0 = -adytail;
+            s1 = bdxtail * n1;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * n1;
+            bhi = c - (c - n1);
+            blo = n1 - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = bdx * n0;
+            c = splitter * bdx;
+            ahi = c - (c - bdx);
+            alo = bdx - ahi;
+            c = splitter * n0;
+            bhi = c - (c - n0);
+            blo = n0 - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            v[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            v[3] = u3;
+            abtlen = sum(4, u, 4, v, abt);
+            s1 = adxtail * bdytail;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * bdytail;
+            bhi = c - (c - bdytail);
+            blo = bdytail - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = bdxtail * adytail;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * adytail;
+            bhi = c - (c - adytail);
+            blo = adytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 - t0;
+            bvirt = s0 - _i;
+            abtt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            abtt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            abtt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            abtt[3] = u3;
+            abttlen = 4;
+        } else {
+            abt[0] = 0;
+            abtlen = 1;
+            abtt[0] = 0;
+            abttlen = 1;
+        }
+        if (cdxtail !== 0) {
+            const len = scale(abtlen, abt, cdxtail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(cxtablen, cxtab, cdxtail, _16), _16,
+                scale(len, _16c, 2 * cdx, _32), _32, _48), _48);
+
+            const len2 = scale(abttlen, abtt, cdxtail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * cdx, _16), _16,
+                scale(len2, _8, cdxtail, _16b), _16b,
+                scale(len, _16c, cdxtail, _32), _32, _32b, _64), _64);
+
+            if (adytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, bb, cdxtail, _8), _8, adytail, _16), _16);
+            }
+            if (bdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, aa, -cdxtail, _8), _8, bdytail, _16), _16);
+            }
+        }
+        if (cdytail !== 0) {
+            const len = scale(abtlen, abt, cdytail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(cytablen, cytab, cdytail, _16), _16,
+                scale(len, _16c, 2 * cdy, _32), _32, _48), _48);
+
+            const len2 = scale(abttlen, abtt, cdytail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * cdy, _16), _16,
+                scale(len2, _8, cdytail, _16b), _16b,
+                scale(len, _16c, cdytail, _32), _32, _32b, _64), _64);
+        }
+    }
+
+    return fin[finlen - 1];
+}
+
+function incircle(ax, ay, bx, by, cx, cy, dx, dy) {
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+
+    const bdxcdy = bdx * cdy;
+    const cdxbdy = cdx * bdy;
+    const alift = adx * adx + ady * ady;
+
+    const cdxady = cdx * ady;
+    const adxcdy = adx * cdy;
+    const blift = bdx * bdx + bdy * bdy;
+
+    const adxbdy = adx * bdy;
+    const bdxady = bdx * ady;
+    const clift = cdx * cdx + cdy * cdy;
+
+    const det =
+        alift * (bdxcdy - cdxbdy) +
+        blift * (cdxady - adxcdy) +
+        clift * (adxbdy - bdxady);
+
+    const permanent =
+        (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * alift +
+        (Math.abs(cdxady) + Math.abs(adxcdy)) * blift +
+        (Math.abs(adxbdy) + Math.abs(bdxady)) * clift;
+
+    const errbound = iccerrboundA * permanent;
+
+    if (det > errbound || -det > errbound) {
+        return det;
+    }
+    return incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent);
+}
+
+function incirclefast(ax, ay, bx, by, cx, cy, dx, dy) {
+    const adx = ax - dx;
+    const ady = ay - dy;
+    const bdx = bx - dx;
+    const bdy = by - dy;
+    const cdx = cx - dx;
+    const cdy = cy - dy;
+
+    const abdet = adx * bdy - bdx * ady;
+    const bcdet = bdx * cdy - cdx * bdy;
+    const cadet = cdx * ady - adx * cdy;
+    const alift = adx * adx + ady * ady;
+    const blift = bdx * bdx + bdy * bdy;
+    const clift = cdx * cdx + cdy * cdy;
+
+    return alift * bcdet + blift * cadet + clift * abdet;
+}
+
+exports.incircle = incircle;
+exports.incirclefast = incirclefast;
+
+}));
diff --git a/tools/ui/node_modules/robust-predicates/umd/incircle.min.js b/tools/ui/node_modules/robust-predicates/umd/incircle.min.js
new file mode 100644
index 0000000000000000000000000000000000000000..d8edfdfdfa8366b0e8a3b8c31c71a62d4a9d8324
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/umd/incircle.min.js
@@ -0,0 +1 @@
+!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((t="undefined"!=typeof globalThis?globalThis:t||self).predicates={})}(this,function(t){"use strict";const n=11102230246251565e-32,e=134217729,o=(3+8*n)*n;function f(t,n,e,o,f){let i,r,c,s,u=n[0],a=o[0],l=0,b=0;a>u==a>-u?(i=u,u=n[++l]):(i=a,a=o[++b]);let d=0;if(lu==a>-u?(r=u+i,c=i-(r-u),u=n[++l]):(r=a+i,c=i-(r-a),a=o[++b]),i=r,0!==c&&(f[d++]=c);lu==a>-u?(r=i+u,s=r-i,c=i-(r-s)+(u-s),u=n[++l]):(r=i+a,s=r-i,c=i-(r-s)+(a-s),a=o[++b]),i=r,0!==c&&(f[d++]=c);for(;lrt||-ft>rt?ft:function(t,n,c,J,L,N,O,P,Q){let R,S,U,V,W,X,Y,Z,$,_,tt,nt,et,ot,ft,it,rt,ct,st,ut,at,lt,bt,dt,ht,pt,Mt,yt,xt,gt,mt,Tt,jt,wt,At;const Ft=t-O,kt=c-O,qt=L-O,vt=n-P,zt=J-P,Bt=N-P;mt=kt*Bt,bt=e*kt,dt=bt-(bt-kt),ht=kt-dt,bt=e*Bt,pt=bt-(bt-Bt),Mt=Bt-pt,Tt=ht*Mt-(mt-dt*pt-ht*pt-dt*Mt),jt=qt*zt,bt=e*qt,dt=bt-(bt-qt),ht=qt-dt,bt=e*zt,pt=bt-(bt-zt),Mt=zt-pt,wt=ht*Mt-(jt-dt*pt-ht*pt-dt*Mt),yt=Tt-wt,lt=Tt-yt,s[0]=Tt-(yt+lt)+(lt-wt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt-jt,lt=gt-yt,s[1]=gt-(yt+lt)+(lt-jt),At=xt+yt,lt=At-xt,s[2]=xt-(At-lt)+(yt-lt),s[3]=At,mt=qt*vt,bt=e*qt,dt=bt-(bt-qt),ht=qt-dt,bt=e*vt,pt=bt-(bt-vt),Mt=vt-pt,Tt=ht*Mt-(mt-dt*pt-ht*pt-dt*Mt),jt=Ft*Bt,bt=e*Ft,dt=bt-(bt-Ft),ht=Ft-dt,bt=e*Bt,pt=bt-(bt-Bt),Mt=Bt-pt,wt=ht*Mt-(jt-dt*pt-ht*pt-dt*Mt),yt=Tt-wt,lt=Tt-yt,u[0]=Tt-(yt+lt)+(lt-wt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt-jt,lt=gt-yt,u[1]=gt-(yt+lt)+(lt-jt),At=xt+yt,lt=At-xt,u[2]=xt-(At-lt)+(yt-lt),u[3]=At,mt=Ft*zt,bt=e*Ft,dt=bt-(bt-Ft),ht=Ft-dt,bt=e*zt,pt=bt-(bt-zt),Mt=zt-pt,Tt=ht*Mt-(mt-dt*pt-ht*pt-dt*Mt),jt=kt*vt,bt=e*kt,dt=bt-(bt-kt),ht=kt-dt,bt=e*vt,pt=bt-(bt-vt),Mt=vt-pt,wt=ht*Mt-(jt-dt*pt-ht*pt-dt*Mt),yt=Tt-wt,lt=Tt-yt,a[0]=Tt-(yt+lt)+(lt-wt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt-jt,lt=gt-yt,a[1]=gt-(yt+lt)+(lt-jt),At=xt+yt,lt=At-xt,a[2]=xt-(At-lt)+(yt-lt),a[3]=At,R=f(f(f(r(r(4,s,Ft,v),v,Ft,z),z,r(r(4,s,vt,v),v,vt,B),B,D),D,f(r(r(4,u,kt,v),v,kt,z),z,r(r(4,u,zt,v),v,zt,B),B,E),E,H),H,f(r(r(4,a,qt,v),v,qt,z),z,r(r(4,a,Bt,v),v,Bt,B),B,D),D,I);let Ct=function(t,n){let e=n[0];for(let o=1;o=Dt||-Ct>=Dt)return Ct;if(lt=t-Ft,S=t-(Ft+lt)+(lt-O),lt=n-vt,W=n-(vt+lt)+(lt-P),lt=c-kt,U=c-(kt+lt)+(lt-O),lt=J-zt,X=J-(zt+lt)+(lt-P),lt=L-qt,V=L-(qt+lt)+(lt-O),lt=N-Bt,Y=N-(Bt+lt)+(lt-P),0===S&&0===U&&0===V&&0===W&&0===X&&0===Y)return Ct;if(Dt=5423418723394464e-46*Q+o*Math.abs(Ct),Ct+=(Ft*Ft+vt*vt)*(kt*Y+Bt*U-(zt*V+qt*X))+2*(Ft*S+vt*W)*(kt*Bt-zt*qt)+((kt*kt+zt*zt)*(qt*W+vt*V-(Bt*S+Ft*Y))+2*(kt*U+zt*X)*(qt*vt-Bt*Ft))+((qt*qt+Bt*Bt)*(Ft*X+zt*S-(vt*U+kt*W))+2*(qt*V+Bt*Y)*(Ft*zt-vt*kt)),Ct>=Dt||-Ct>=Dt)return Ct;if(0===U&&0===X&&0===V&&0===Y||(mt=Ft*Ft,bt=e*Ft,dt=bt-(bt-Ft),ht=Ft-dt,Tt=ht*ht-(mt-dt*dt-(dt+dt)*ht),jt=vt*vt,bt=e*vt,dt=bt-(bt-vt),ht=vt-dt,wt=ht*ht-(jt-dt*dt-(dt+dt)*ht),yt=Tt+wt,lt=yt-Tt,l[0]=Tt-(yt-lt)+(wt-lt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt+jt,lt=yt-gt,l[1]=gt-(yt-lt)+(jt-lt),At=xt+yt,lt=At-xt,l[2]=xt-(At-lt)+(yt-lt),l[3]=At),0===V&&0===Y&&0===S&&0===W||(mt=kt*kt,bt=e*kt,dt=bt-(bt-kt),ht=kt-dt,Tt=ht*ht-(mt-dt*dt-(dt+dt)*ht),jt=zt*zt,bt=e*zt,dt=bt-(bt-zt),ht=zt-dt,wt=ht*ht-(jt-dt*dt-(dt+dt)*ht),yt=Tt+wt,lt=yt-Tt,b[0]=Tt-(yt-lt)+(wt-lt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt+jt,lt=yt-gt,b[1]=gt-(yt-lt)+(jt-lt),At=xt+yt,lt=At-xt,b[2]=xt-(At-lt)+(yt-lt),b[3]=At),0===S&&0===W&&0===U&&0===X||(mt=qt*qt,bt=e*qt,dt=bt-(bt-qt),ht=qt-dt,Tt=ht*ht-(mt-dt*dt-(dt+dt)*ht),jt=Bt*Bt,bt=e*Bt,dt=bt-(bt-Bt),ht=Bt-dt,wt=ht*ht-(jt-dt*dt-(dt+dt)*ht),yt=Tt+wt,lt=yt-Tt,d[0]=Tt-(yt-lt)+(wt-lt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt+jt,lt=yt-gt,d[1]=gt-(yt-lt)+(jt-lt),At=xt+yt,lt=At-xt,d[2]=xt-(At-lt)+(yt-lt),d[3]=At),0!==S&&(Z=r(4,s,S,M),R=K(R,i(r(Z,M,2*Ft,z),z,r(r(4,d,S,v),v,zt,B),B,r(r(4,b,S,v),v,-Bt,C),C,D,G),G)),0!==W&&($=r(4,s,W,y),R=K(R,i(r($,y,2*vt,z),z,r(r(4,b,W,v),v,qt,B),B,r(r(4,d,W,v),v,-kt,C),C,D,G),G)),0!==U&&(_=r(4,u,U,x),R=K(R,i(r(_,x,2*kt,z),z,r(r(4,l,U,v),v,Bt,B),B,r(r(4,d,U,v),v,-vt,C),C,D,G),G)),0!==X&&(tt=r(4,u,X,g),R=K(R,i(r(tt,g,2*zt,z),z,r(r(4,d,X,v),v,Ft,B),B,r(r(4,l,X,v),v,-qt,C),C,D,G),G)),0!==V&&(nt=r(4,a,V,m),R=K(R,i(r(nt,m,2*qt,z),z,r(r(4,b,V,v),v,vt,B),B,r(r(4,l,V,v),v,-zt,C),C,D,G),G)),0!==Y&&(et=r(4,a,Y,T),R=K(R,i(r(et,T,2*Bt,z),z,r(r(4,l,Y,v),v,kt,B),B,r(r(4,b,Y,v),v,-Ft,C),C,D,G),G)),0!==S||0!==W){if(0!==U||0!==X||0!==V||0!==Y?(mt=U*Bt,bt=e*U,dt=bt-(bt-U),ht=U-dt,bt=e*Bt,pt=bt-(bt-Bt),Mt=Bt-pt,Tt=ht*Mt-(mt-dt*pt-ht*pt-dt*Mt),jt=kt*Y,bt=e*kt,dt=bt-(bt-kt),ht=kt-dt,bt=e*Y,pt=bt-(bt-Y),Mt=Y-pt,wt=ht*Mt-(jt-dt*pt-ht*pt-dt*Mt),yt=Tt+wt,lt=yt-Tt,h[0]=Tt-(yt-lt)+(wt-lt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt+jt,lt=yt-gt,h[1]=gt-(yt-lt)+(jt-lt),At=xt+yt,lt=At-xt,h[2]=xt-(At-lt)+(yt-lt),h[3]=At,mt=V*-zt,bt=e*V,dt=bt-(bt-V),ht=V-dt,bt=e*-zt,pt=bt-(bt- -zt),Mt=-zt-pt,Tt=ht*Mt-(mt-dt*pt-ht*pt-dt*Mt),jt=qt*-X,bt=e*qt,dt=bt-(bt-qt),ht=qt-dt,bt=e*-X,pt=bt-(bt- -X),Mt=-X-pt,wt=ht*Mt-(jt-dt*pt-ht*pt-dt*Mt),yt=Tt+wt,lt=yt-Tt,p[0]=Tt-(yt-lt)+(wt-lt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt+jt,lt=yt-gt,p[1]=gt-(yt-lt)+(jt-lt),At=xt+yt,lt=At-xt,p[2]=xt-(At-lt)+(yt-lt),p[3]=At,ft=f(4,h,4,p,w),mt=U*Y,bt=e*U,dt=bt-(bt-U),ht=U-dt,bt=e*Y,pt=bt-(bt-Y),Mt=Y-pt,Tt=ht*Mt-(mt-dt*pt-ht*pt-dt*Mt),jt=V*X,bt=e*V,dt=bt-(bt-V),ht=V-dt,bt=e*X,pt=bt-(bt-X),Mt=X-pt,wt=ht*Mt-(jt-dt*pt-ht*pt-dt*Mt),yt=Tt-wt,lt=Tt-yt,k[0]=Tt-(yt+lt)+(lt-wt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt-jt,lt=gt-yt,k[1]=gt-(yt+lt)+(lt-jt),At=xt+yt,lt=At-xt,k[2]=xt-(At-lt)+(yt-lt),k[3]=At,ct=4):(w[0]=0,ft=1,k[0]=0,ct=1),0!==S){const t=r(ft,w,S,C);R=K(R,f(r(Z,M,S,z),z,r(t,C,2*Ft,D),D,G),G);const n=r(ct,k,S,v);R=K(R,i(r(n,v,2*Ft,z),z,r(n,v,S,B),B,r(t,C,S,D),D,E,H),H),0!==X&&(R=K(R,r(r(4,d,S,v),v,X,z),z)),0!==Y&&(R=K(R,r(r(4,b,-S,v),v,Y,z),z))}if(0!==W){const t=r(ft,w,W,C);R=K(R,f(r($,y,W,z),z,r(t,C,2*vt,D),D,G),G);const n=r(ct,k,W,v);R=K(R,i(r(n,v,2*vt,z),z,r(n,v,W,B),B,r(t,C,W,D),D,E,H),H)}}if(0!==U||0!==X){if(0!==V||0!==Y||0!==S||0!==W?(mt=V*vt,bt=e*V,dt=bt-(bt-V),ht=V-dt,bt=e*vt,pt=bt-(bt-vt),Mt=vt-pt,Tt=ht*Mt-(mt-dt*pt-ht*pt-dt*Mt),jt=qt*W,bt=e*qt,dt=bt-(bt-qt),ht=qt-dt,bt=e*W,pt=bt-(bt-W),Mt=W-pt,wt=ht*Mt-(jt-dt*pt-ht*pt-dt*Mt),yt=Tt+wt,lt=yt-Tt,h[0]=Tt-(yt-lt)+(wt-lt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt+jt,lt=yt-gt,h[1]=gt-(yt-lt)+(jt-lt),At=xt+yt,lt=At-xt,h[2]=xt-(At-lt)+(yt-lt),h[3]=At,ut=-Bt,at=-Y,mt=S*ut,bt=e*S,dt=bt-(bt-S),ht=S-dt,bt=e*ut,pt=bt-(bt-ut),Mt=ut-pt,Tt=ht*Mt-(mt-dt*pt-ht*pt-dt*Mt),jt=Ft*at,bt=e*Ft,dt=bt-(bt-Ft),ht=Ft-dt,bt=e*at,pt=bt-(bt-at),Mt=at-pt,wt=ht*Mt-(jt-dt*pt-ht*pt-dt*Mt),yt=Tt+wt,lt=yt-Tt,p[0]=Tt-(yt-lt)+(wt-lt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt+jt,lt=yt-gt,p[1]=gt-(yt-lt)+(jt-lt),At=xt+yt,lt=At-xt,p[2]=xt-(At-lt)+(yt-lt),p[3]=At,it=f(4,h,4,p,A),mt=V*W,bt=e*V,dt=bt-(bt-V),ht=V-dt,bt=e*W,pt=bt-(bt-W),Mt=W-pt,Tt=ht*Mt-(mt-dt*pt-ht*pt-dt*Mt),jt=S*Y,bt=e*S,dt=bt-(bt-S),ht=S-dt,bt=e*Y,pt=bt-(bt-Y),Mt=Y-pt,wt=ht*Mt-(jt-dt*pt-ht*pt-dt*Mt),yt=Tt-wt,lt=Tt-yt,q[0]=Tt-(yt+lt)+(lt-wt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt-jt,lt=gt-yt,q[1]=gt-(yt+lt)+(lt-jt),At=xt+yt,lt=At-xt,q[2]=xt-(At-lt)+(yt-lt),q[3]=At,st=4):(A[0]=0,it=1,q[0]=0,st=1),0!==U){const t=r(it,A,U,C);R=K(R,f(r(_,x,U,z),z,r(t,C,2*kt,D),D,G),G);const n=r(st,q,U,v);R=K(R,i(r(n,v,2*kt,z),z,r(n,v,U,B),B,r(t,C,U,D),D,E,H),H),0!==Y&&(R=K(R,r(r(4,l,U,v),v,Y,z),z)),0!==W&&(R=K(R,r(r(4,d,-U,v),v,W,z),z))}if(0!==X){const t=r(it,A,X,C);R=K(R,f(r(tt,g,X,z),z,r(t,C,2*zt,D),D,G),G);const n=r(st,q,X,v);R=K(R,i(r(n,v,2*zt,z),z,r(n,v,X,B),B,r(t,C,X,D),D,E,H),H)}}if(0!==V||0!==Y){if(0!==S||0!==W||0!==U||0!==X?(mt=S*zt,bt=e*S,dt=bt-(bt-S),ht=S-dt,bt=e*zt,pt=bt-(bt-zt),Mt=zt-pt,Tt=ht*Mt-(mt-dt*pt-ht*pt-dt*Mt),jt=Ft*X,bt=e*Ft,dt=bt-(bt-Ft),ht=Ft-dt,bt=e*X,pt=bt-(bt-X),Mt=X-pt,wt=ht*Mt-(jt-dt*pt-ht*pt-dt*Mt),yt=Tt+wt,lt=yt-Tt,h[0]=Tt-(yt-lt)+(wt-lt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt+jt,lt=yt-gt,h[1]=gt-(yt-lt)+(jt-lt),At=xt+yt,lt=At-xt,h[2]=xt-(At-lt)+(yt-lt),h[3]=At,ut=-vt,at=-W,mt=U*ut,bt=e*U,dt=bt-(bt-U),ht=U-dt,bt=e*ut,pt=bt-(bt-ut),Mt=ut-pt,Tt=ht*Mt-(mt-dt*pt-ht*pt-dt*Mt),jt=kt*at,bt=e*kt,dt=bt-(bt-kt),ht=kt-dt,bt=e*at,pt=bt-(bt-at),Mt=at-pt,wt=ht*Mt-(jt-dt*pt-ht*pt-dt*Mt),yt=Tt+wt,lt=yt-Tt,p[0]=Tt-(yt-lt)+(wt-lt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt+jt,lt=yt-gt,p[1]=gt-(yt-lt)+(jt-lt),At=xt+yt,lt=At-xt,p[2]=xt-(At-lt)+(yt-lt),p[3]=At,ot=f(4,h,4,p,j),mt=S*X,bt=e*S,dt=bt-(bt-S),ht=S-dt,bt=e*X,pt=bt-(bt-X),Mt=X-pt,Tt=ht*Mt-(mt-dt*pt-ht*pt-dt*Mt),jt=U*W,bt=e*U,dt=bt-(bt-U),ht=U-dt,bt=e*W,pt=bt-(bt-W),Mt=W-pt,wt=ht*Mt-(jt-dt*pt-ht*pt-dt*Mt),yt=Tt-wt,lt=Tt-yt,F[0]=Tt-(yt+lt)+(lt-wt),xt=mt+yt,lt=xt-mt,gt=mt-(xt-lt)+(yt-lt),yt=gt-jt,lt=gt-yt,F[1]=gt-(yt+lt)+(lt-jt),At=xt+yt,lt=At-xt,F[2]=xt-(At-lt)+(yt-lt),F[3]=At,rt=4):(j[0]=0,ot=1,F[0]=0,rt=1),0!==V){const t=r(ot,j,V,C);R=K(R,f(r(nt,m,V,z),z,r(t,C,2*qt,D),D,G),G);const n=r(rt,F,V,v);R=K(R,i(r(n,v,2*qt,z),z,r(n,v,V,B),B,r(t,C,V,D),D,E,H),H),0!==W&&(R=K(R,r(r(4,b,V,v),v,W,z),z)),0!==X&&(R=K(R,r(r(4,l,-V,v),v,X,z),z))}if(0!==Y){const t=r(ot,j,Y,C);R=K(R,f(r(et,T,Y,z),z,r(t,C,2*Bt,D),D,G),G);const n=r(rt,F,Y,v);R=K(R,i(r(n,v,2*Bt,z),z,r(n,v,Y,B),B,r(t,C,Y,D),D,E,H),H)}}return I[R-1]}(t,n,c,J,L,N,O,P,it)},t.incirclefast=function(t,n,e,o,f,i,r,c){const s=t-r,u=n-c,a=e-r,l=o-c,b=f-r,d=i-c;return(s*s+u*u)*(a*d-b*l)+(a*a+l*l)*(b*u-s*d)+(b*b+d*d)*(s*l-a*u)}});
diff --git a/tools/ui/node_modules/robust-predicates/umd/insphere.js b/tools/ui/node_modules/robust-predicates/umd/insphere.js
new file mode 100644
index 0000000000000000000000000000000000000000..b33779bca5b390dbb4300e8170fd25b127c4328e
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/umd/insphere.js
@@ -0,0 +1,914 @@
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+typeof define === 'function' && define.amd ? define(['exports'], factory) :
+(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.predicates = {}));
+})(this, (function (exports) { 'use strict';
+
+const epsilon = 1.1102230246251565e-16;
+const splitter = 134217729;
+const resulterrbound = (3 + 8 * epsilon) * epsilon;
+
+// fast_expansion_sum_zeroelim routine from original code
+function sum(elen, e, flen, f, h) {
+    let Q, Qnew, hh, bvirt;
+    let enow = e[0];
+    let fnow = f[0];
+    let eindex = 0;
+    let findex = 0;
+    if ((fnow > enow) === (fnow > -enow)) {
+        Q = enow;
+        enow = e[++eindex];
+    } else {
+        Q = fnow;
+        fnow = f[++findex];
+    }
+    let hindex = 0;
+    if (eindex < elen && findex < flen) {
+        if ((fnow > enow) === (fnow > -enow)) {
+            Qnew = enow + Q;
+            hh = Q - (Qnew - enow);
+            enow = e[++eindex];
+        } else {
+            Qnew = fnow + Q;
+            hh = Q - (Qnew - fnow);
+            fnow = f[++findex];
+        }
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        while (eindex < elen && findex < flen) {
+            if ((fnow > enow) === (fnow > -enow)) {
+                Qnew = Q + enow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (enow - bvirt);
+                enow = e[++eindex];
+            } else {
+                Qnew = Q + fnow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+                fnow = f[++findex];
+            }
+            Q = Qnew;
+            if (hh !== 0) {
+                h[hindex++] = hh;
+            }
+        }
+    }
+    while (eindex < elen) {
+        Qnew = Q + enow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (enow - bvirt);
+        enow = e[++eindex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    while (findex < flen) {
+        Qnew = Q + fnow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+        fnow = f[++findex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+function sum_three(alen, a, blen, b, clen, c, tmp, out) {
+    return sum(sum(alen, a, blen, b, tmp), tmp, clen, c, out);
+}
+
+// scale_expansion_zeroelim routine from oritinal code
+function scale(elen, e, b, h) {
+    let Q, sum, hh, product1, product0;
+    let bvirt, c, ahi, alo, bhi, blo;
+
+    c = splitter * b;
+    bhi = c - (c - b);
+    blo = b - bhi;
+    let enow = e[0];
+    Q = enow * b;
+    c = splitter * enow;
+    ahi = c - (c - enow);
+    alo = enow - ahi;
+    hh = alo * blo - (Q - ahi * bhi - alo * bhi - ahi * blo);
+    let hindex = 0;
+    if (hh !== 0) {
+        h[hindex++] = hh;
+    }
+    for (let i = 1; i < elen; i++) {
+        enow = e[i];
+        product1 = enow * b;
+        c = splitter * enow;
+        ahi = c - (c - enow);
+        alo = enow - ahi;
+        product0 = alo * blo - (product1 - ahi * bhi - alo * bhi - ahi * blo);
+        sum = Q + product0;
+        bvirt = sum - Q;
+        hh = Q - (sum - bvirt) + (product0 - bvirt);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        Q = product1 + sum;
+        hh = sum - (Q - product1);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+function negate(elen, e) {
+    for (let i = 0; i < elen; i++) e[i] = -e[i];
+    return elen;
+}
+
+function estimate(elen, e) {
+    let Q = e[0];
+    for (let i = 1; i < elen; i++) Q += e[i];
+    return Q;
+}
+
+function vec(n) {
+    return new Float64Array(n);
+}
+
+const isperrboundA = (16 + 224 * epsilon) * epsilon;
+const isperrboundB = (5 + 72 * epsilon) * epsilon;
+const isperrboundC = (71 + 1408 * epsilon) * epsilon * epsilon;
+
+const ab = vec(4);
+const bc = vec(4);
+const cd = vec(4);
+const de = vec(4);
+const ea = vec(4);
+const ac = vec(4);
+const bd = vec(4);
+const ce = vec(4);
+const da = vec(4);
+const eb = vec(4);
+
+const abc = vec(24);
+const bcd = vec(24);
+const cde = vec(24);
+const dea = vec(24);
+const eab = vec(24);
+const abd = vec(24);
+const bce = vec(24);
+const cda = vec(24);
+const deb = vec(24);
+const eac = vec(24);
+
+const adet = vec(1152);
+const bdet = vec(1152);
+const cdet = vec(1152);
+const ddet = vec(1152);
+const edet = vec(1152);
+const abdet = vec(2304);
+const cddet = vec(2304);
+const cdedet = vec(3456);
+const deter = vec(5760);
+
+const _8 = vec(8);
+const _8b = vec(8);
+const _8c = vec(8);
+const _16 = vec(16);
+const _24 = vec(24);
+const _48 = vec(48);
+const _48b = vec(48);
+const _96 = vec(96);
+const _192 = vec(192);
+const _384x = vec(384);
+const _384y = vec(384);
+const _384z = vec(384);
+const _768 = vec(768);
+
+function sum_three_scale(a, b, c, az, bz, cz, out) {
+    return sum_three(
+        scale(4, a, az, _8), _8,
+        scale(4, b, bz, _8b), _8b,
+        scale(4, c, cz, _8c), _8c, _16, out);
+}
+
+function liftexact(alen, a, blen, b, clen, c, dlen, d, x, y, z, out) {
+    const len = sum(
+        sum(alen, a, blen, b, _48), _48,
+        negate(sum(clen, c, dlen, d, _48b), _48b), _48b, _96);
+
+    return sum_three(
+        scale(scale(len, _96, x, _192), _192, x, _384x), _384x,
+        scale(scale(len, _96, y, _192), _192, y, _384y), _384y,
+        scale(scale(len, _96, z, _192), _192, z, _384z), _384z, _768, out);
+}
+
+function insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    s1 = ax * by;
+    c = splitter * ax;
+    ahi = c - (c - ax);
+    alo = ax - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bx * ay;
+    c = splitter * bx;
+    ahi = c - (c - bx);
+    alo = bx - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ab[3] = u3;
+    s1 = bx * cy;
+    c = splitter * bx;
+    ahi = c - (c - bx);
+    alo = bx - ahi;
+    c = splitter * cy;
+    bhi = c - (c - cy);
+    blo = cy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cx * by;
+    c = splitter * cx;
+    ahi = c - (c - cx);
+    alo = cx - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bc[3] = u3;
+    s1 = cx * dy;
+    c = splitter * cx;
+    ahi = c - (c - cx);
+    alo = cx - ahi;
+    c = splitter * dy;
+    bhi = c - (c - dy);
+    blo = dy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = dx * cy;
+    c = splitter * dx;
+    ahi = c - (c - dx);
+    alo = dx - ahi;
+    c = splitter * cy;
+    bhi = c - (c - cy);
+    blo = cy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    cd[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    cd[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    cd[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    cd[3] = u3;
+    s1 = dx * ey;
+    c = splitter * dx;
+    ahi = c - (c - dx);
+    alo = dx - ahi;
+    c = splitter * ey;
+    bhi = c - (c - ey);
+    blo = ey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ex * dy;
+    c = splitter * ex;
+    ahi = c - (c - ex);
+    alo = ex - ahi;
+    c = splitter * dy;
+    bhi = c - (c - dy);
+    blo = dy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    de[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    de[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    de[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    de[3] = u3;
+    s1 = ex * ay;
+    c = splitter * ex;
+    ahi = c - (c - ex);
+    alo = ex - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ax * ey;
+    c = splitter * ax;
+    ahi = c - (c - ax);
+    alo = ax - ahi;
+    c = splitter * ey;
+    bhi = c - (c - ey);
+    blo = ey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ea[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ea[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ea[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ea[3] = u3;
+    s1 = ax * cy;
+    c = splitter * ax;
+    ahi = c - (c - ax);
+    alo = ax - ahi;
+    c = splitter * cy;
+    bhi = c - (c - cy);
+    blo = cy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cx * ay;
+    c = splitter * cx;
+    ahi = c - (c - cx);
+    alo = cx - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ac[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ac[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ac[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ac[3] = u3;
+    s1 = bx * dy;
+    c = splitter * bx;
+    ahi = c - (c - bx);
+    alo = bx - ahi;
+    c = splitter * dy;
+    bhi = c - (c - dy);
+    blo = dy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = dx * by;
+    c = splitter * dx;
+    ahi = c - (c - dx);
+    alo = dx - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bd[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bd[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bd[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bd[3] = u3;
+    s1 = cx * ey;
+    c = splitter * cx;
+    ahi = c - (c - cx);
+    alo = cx - ahi;
+    c = splitter * ey;
+    bhi = c - (c - ey);
+    blo = ey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ex * cy;
+    c = splitter * ex;
+    ahi = c - (c - ex);
+    alo = ex - ahi;
+    c = splitter * cy;
+    bhi = c - (c - cy);
+    blo = cy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ce[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ce[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ce[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ce[3] = u3;
+    s1 = dx * ay;
+    c = splitter * dx;
+    ahi = c - (c - dx);
+    alo = dx - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ax * dy;
+    c = splitter * ax;
+    ahi = c - (c - ax);
+    alo = ax - ahi;
+    c = splitter * dy;
+    bhi = c - (c - dy);
+    blo = dy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    da[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    da[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    da[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    da[3] = u3;
+    s1 = ex * by;
+    c = splitter * ex;
+    ahi = c - (c - ex);
+    alo = ex - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bx * ey;
+    c = splitter * bx;
+    ahi = c - (c - bx);
+    alo = bx - ahi;
+    c = splitter * ey;
+    bhi = c - (c - ey);
+    blo = ey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    eb[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    eb[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    eb[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    eb[3] = u3;
+
+    const abclen = sum_three_scale(ab, bc, ac, cz, az, -bz, abc);
+    const bcdlen = sum_three_scale(bc, cd, bd, dz, bz, -cz, bcd);
+    const cdelen = sum_three_scale(cd, de, ce, ez, cz, -dz, cde);
+    const dealen = sum_three_scale(de, ea, da, az, dz, -ez, dea);
+    const eablen = sum_three_scale(ea, ab, eb, bz, ez, -az, eab);
+    const abdlen = sum_three_scale(ab, bd, da, dz, az, bz, abd);
+    const bcelen = sum_three_scale(bc, ce, eb, ez, bz, cz, bce);
+    const cdalen = sum_three_scale(cd, da, ac, az, cz, dz, cda);
+    const deblen = sum_three_scale(de, eb, bd, bz, dz, ez, deb);
+    const eaclen = sum_three_scale(ea, ac, ce, cz, ez, az, eac);
+
+    const deterlen = sum_three(
+        liftexact(cdelen, cde, bcelen, bce, deblen, deb, bcdlen, bcd, ax, ay, az, adet), adet,
+        liftexact(dealen, dea, cdalen, cda, eaclen, eac, cdelen, cde, bx, by, bz, bdet), bdet,
+        sum_three(
+            liftexact(eablen, eab, deblen, deb, abdlen, abd, dealen, dea, cx, cy, cz, cdet), cdet,
+            liftexact(abclen, abc, eaclen, eac, bcelen, bce, eablen, eab, dx, dy, dz, ddet), ddet,
+            liftexact(bcdlen, bcd, abdlen, abd, cdalen, cda, abclen, abc, ex, ey, ez, edet), edet, cddet, cdedet), cdedet, abdet, deter);
+
+    return deter[deterlen - 1];
+}
+
+const xdet = vec(96);
+const ydet = vec(96);
+const zdet = vec(96);
+const fin = vec(1152);
+
+function liftadapt(a, b, c, az, bz, cz, x, y, z, out) {
+    const len = sum_three_scale(a, b, c, az, bz, cz, _24);
+    return sum_three(
+        scale(scale(len, _24, x, _48), _48, x, xdet), xdet,
+        scale(scale(len, _24, y, _48), _48, y, ydet), ydet,
+        scale(scale(len, _24, z, _48), _48, z, zdet), zdet, _192, out);
+}
+
+function insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez, permanent) {
+    let ab3, bc3, cd3, da3, ac3, bd3;
+
+    let aextail, bextail, cextail, dextail;
+    let aeytail, beytail, ceytail, deytail;
+    let aeztail, beztail, ceztail, deztail;
+
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0;
+
+    const aex = ax - ex;
+    const bex = bx - ex;
+    const cex = cx - ex;
+    const dex = dx - ex;
+    const aey = ay - ey;
+    const bey = by - ey;
+    const cey = cy - ey;
+    const dey = dy - ey;
+    const aez = az - ez;
+    const bez = bz - ez;
+    const cez = cz - ez;
+    const dez = dz - ez;
+
+    s1 = aex * bey;
+    c = splitter * aex;
+    ahi = c - (c - aex);
+    alo = aex - ahi;
+    c = splitter * bey;
+    bhi = c - (c - bey);
+    blo = bey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bex * aey;
+    c = splitter * bex;
+    ahi = c - (c - bex);
+    alo = bex - ahi;
+    c = splitter * aey;
+    bhi = c - (c - aey);
+    blo = aey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    ab3 = _j + _i;
+    bvirt = ab3 - _j;
+    ab[2] = _j - (ab3 - bvirt) + (_i - bvirt);
+    ab[3] = ab3;
+    s1 = bex * cey;
+    c = splitter * bex;
+    ahi = c - (c - bex);
+    alo = bex - ahi;
+    c = splitter * cey;
+    bhi = c - (c - cey);
+    blo = cey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cex * bey;
+    c = splitter * cex;
+    ahi = c - (c - cex);
+    alo = cex - ahi;
+    c = splitter * bey;
+    bhi = c - (c - bey);
+    blo = bey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    bc3 = _j + _i;
+    bvirt = bc3 - _j;
+    bc[2] = _j - (bc3 - bvirt) + (_i - bvirt);
+    bc[3] = bc3;
+    s1 = cex * dey;
+    c = splitter * cex;
+    ahi = c - (c - cex);
+    alo = cex - ahi;
+    c = splitter * dey;
+    bhi = c - (c - dey);
+    blo = dey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = dex * cey;
+    c = splitter * dex;
+    ahi = c - (c - dex);
+    alo = dex - ahi;
+    c = splitter * cey;
+    bhi = c - (c - cey);
+    blo = cey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    cd[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    cd[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    cd3 = _j + _i;
+    bvirt = cd3 - _j;
+    cd[2] = _j - (cd3 - bvirt) + (_i - bvirt);
+    cd[3] = cd3;
+    s1 = dex * aey;
+    c = splitter * dex;
+    ahi = c - (c - dex);
+    alo = dex - ahi;
+    c = splitter * aey;
+    bhi = c - (c - aey);
+    blo = aey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = aex * dey;
+    c = splitter * aex;
+    ahi = c - (c - aex);
+    alo = aex - ahi;
+    c = splitter * dey;
+    bhi = c - (c - dey);
+    blo = dey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    da[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    da[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    da3 = _j + _i;
+    bvirt = da3 - _j;
+    da[2] = _j - (da3 - bvirt) + (_i - bvirt);
+    da[3] = da3;
+    s1 = aex * cey;
+    c = splitter * aex;
+    ahi = c - (c - aex);
+    alo = aex - ahi;
+    c = splitter * cey;
+    bhi = c - (c - cey);
+    blo = cey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cex * aey;
+    c = splitter * cex;
+    ahi = c - (c - cex);
+    alo = cex - ahi;
+    c = splitter * aey;
+    bhi = c - (c - aey);
+    blo = aey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ac[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ac[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    ac3 = _j + _i;
+    bvirt = ac3 - _j;
+    ac[2] = _j - (ac3 - bvirt) + (_i - bvirt);
+    ac[3] = ac3;
+    s1 = bex * dey;
+    c = splitter * bex;
+    ahi = c - (c - bex);
+    alo = bex - ahi;
+    c = splitter * dey;
+    bhi = c - (c - dey);
+    blo = dey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = dex * bey;
+    c = splitter * dex;
+    ahi = c - (c - dex);
+    alo = dex - ahi;
+    c = splitter * bey;
+    bhi = c - (c - bey);
+    blo = bey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bd[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bd[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    bd3 = _j + _i;
+    bvirt = bd3 - _j;
+    bd[2] = _j - (bd3 - bvirt) + (_i - bvirt);
+    bd[3] = bd3;
+
+    const finlen = sum(
+        sum(
+            negate(liftadapt(bc, cd, bd, dez, bez, -cez, aex, aey, aez, adet), adet), adet,
+            liftadapt(cd, da, ac, aez, cez, dez, bex, bey, bez, bdet), bdet, abdet), abdet,
+        sum(
+            negate(liftadapt(da, ab, bd, bez, dez, aez, cex, cey, cez, cdet), cdet), cdet,
+            liftadapt(ab, bc, ac, cez, aez, -bez, dex, dey, dez, ddet), ddet, cddet), cddet, fin);
+
+    let det = estimate(finlen, fin);
+    let errbound = isperrboundB * permanent;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - aex;
+    aextail = ax - (aex + bvirt) + (bvirt - ex);
+    bvirt = ay - aey;
+    aeytail = ay - (aey + bvirt) + (bvirt - ey);
+    bvirt = az - aez;
+    aeztail = az - (aez + bvirt) + (bvirt - ez);
+    bvirt = bx - bex;
+    bextail = bx - (bex + bvirt) + (bvirt - ex);
+    bvirt = by - bey;
+    beytail = by - (bey + bvirt) + (bvirt - ey);
+    bvirt = bz - bez;
+    beztail = bz - (bez + bvirt) + (bvirt - ez);
+    bvirt = cx - cex;
+    cextail = cx - (cex + bvirt) + (bvirt - ex);
+    bvirt = cy - cey;
+    ceytail = cy - (cey + bvirt) + (bvirt - ey);
+    bvirt = cz - cez;
+    ceztail = cz - (cez + bvirt) + (bvirt - ez);
+    bvirt = dx - dex;
+    dextail = dx - (dex + bvirt) + (bvirt - ex);
+    bvirt = dy - dey;
+    deytail = dy - (dey + bvirt) + (bvirt - ey);
+    bvirt = dz - dez;
+    deztail = dz - (dez + bvirt) + (bvirt - ez);
+    if (aextail === 0 && aeytail === 0 && aeztail === 0 &&
+        bextail === 0 && beytail === 0 && beztail === 0 &&
+        cextail === 0 && ceytail === 0 && ceztail === 0 &&
+        dextail === 0 && deytail === 0 && deztail === 0) {
+        return det;
+    }
+
+    errbound = isperrboundC * permanent + resulterrbound * Math.abs(det);
+
+    const abeps = (aex * beytail + bey * aextail) - (aey * bextail + bex * aeytail);
+    const bceps = (bex * ceytail + cey * bextail) - (bey * cextail + cex * beytail);
+    const cdeps = (cex * deytail + dey * cextail) - (cey * dextail + dex * ceytail);
+    const daeps = (dex * aeytail + aey * dextail) - (dey * aextail + aex * deytail);
+    const aceps = (aex * ceytail + cey * aextail) - (aey * cextail + cex * aeytail);
+    const bdeps = (bex * deytail + dey * bextail) - (bey * dextail + dex * beytail);
+    det +=
+        (((bex * bex + bey * bey + bez * bez) * ((cez * daeps + dez * aceps + aez * cdeps) +
+        (ceztail * da3 + deztail * ac3 + aeztail * cd3)) + (dex * dex + dey * dey + dez * dez) *
+        ((aez * bceps - bez * aceps + cez * abeps) + (aeztail * bc3 - beztail * ac3 + ceztail * ab3))) -
+        ((aex * aex + aey * aey + aez * aez) * ((bez * cdeps - cez * bdeps + dez * bceps) +
+        (beztail * cd3 - ceztail * bd3 + deztail * bc3)) + (cex * cex + cey * cey + cez * cez) *
+        ((dez * abeps + aez * bdeps + bez * daeps) + (deztail * ab3 + aeztail * bd3 + beztail * da3)))) +
+        2 * (((bex * bextail + bey * beytail + bez * beztail) * (cez * da3 + dez * ac3 + aez * cd3) +
+        (dex * dextail + dey * deytail + dez * deztail) * (aez * bc3 - bez * ac3 + cez * ab3)) -
+        ((aex * aextail + aey * aeytail + aez * aeztail) * (bez * cd3 - cez * bd3 + dez * bc3) +
+        (cex * cextail + cey * ceytail + cez * ceztail) * (dez * ab3 + aez * bd3 + bez * da3)));
+
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    return insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez);
+}
+
+function insphere(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {
+    const aex = ax - ex;
+    const bex = bx - ex;
+    const cex = cx - ex;
+    const dex = dx - ex;
+    const aey = ay - ey;
+    const bey = by - ey;
+    const cey = cy - ey;
+    const dey = dy - ey;
+    const aez = az - ez;
+    const bez = bz - ez;
+    const cez = cz - ez;
+    const dez = dz - ez;
+
+    const aexbey = aex * bey;
+    const bexaey = bex * aey;
+    const ab = aexbey - bexaey;
+    const bexcey = bex * cey;
+    const cexbey = cex * bey;
+    const bc = bexcey - cexbey;
+    const cexdey = cex * dey;
+    const dexcey = dex * cey;
+    const cd = cexdey - dexcey;
+    const dexaey = dex * aey;
+    const aexdey = aex * dey;
+    const da = dexaey - aexdey;
+    const aexcey = aex * cey;
+    const cexaey = cex * aey;
+    const ac = aexcey - cexaey;
+    const bexdey = bex * dey;
+    const dexbey = dex * bey;
+    const bd = bexdey - dexbey;
+
+    const alift = aex * aex + aey * aey + aez * aez;
+    const blift = bex * bex + bey * bey + bez * bez;
+    const clift = cex * cex + cey * cey + cez * cez;
+    const dlift = dex * dex + dey * dey + dez * dez;
+
+    const det =
+        (clift * (dez * ab + aez * bd + bez * da) - dlift * (aez * bc - bez * ac + cez * ab)) +
+        (alift * (bez * cd - cez * bd + dez * bc) - blift * (cez * da + dez * ac + aez * cd));
+
+    const aezplus = Math.abs(aez);
+    const bezplus = Math.abs(bez);
+    const cezplus = Math.abs(cez);
+    const dezplus = Math.abs(dez);
+    const aexbeyplus = Math.abs(aexbey) + Math.abs(bexaey);
+    const bexceyplus = Math.abs(bexcey) + Math.abs(cexbey);
+    const cexdeyplus = Math.abs(cexdey) + Math.abs(dexcey);
+    const dexaeyplus = Math.abs(dexaey) + Math.abs(aexdey);
+    const aexceyplus = Math.abs(aexcey) + Math.abs(cexaey);
+    const bexdeyplus = Math.abs(bexdey) + Math.abs(dexbey);
+    const permanent =
+        (cexdeyplus * bezplus + bexdeyplus * cezplus + bexceyplus * dezplus) * alift +
+        (dexaeyplus * cezplus + aexceyplus * dezplus + cexdeyplus * aezplus) * blift +
+        (aexbeyplus * dezplus + bexdeyplus * aezplus + dexaeyplus * bezplus) * clift +
+        (bexceyplus * aezplus + aexceyplus * bezplus + aexbeyplus * cezplus) * dlift;
+
+    const errbound = isperrboundA * permanent;
+    if (det > errbound || -det > errbound) {
+        return det;
+    }
+    return -insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez, permanent);
+}
+
+function inspherefast(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {
+    const aex = ax - ex;
+    const bex = bx - ex;
+    const cex = cx - ex;
+    const dex = dx - ex;
+    const aey = ay - ey;
+    const bey = by - ey;
+    const cey = cy - ey;
+    const dey = dy - ey;
+    const aez = az - ez;
+    const bez = bz - ez;
+    const cez = cz - ez;
+    const dez = dz - ez;
+
+    const ab = aex * bey - bex * aey;
+    const bc = bex * cey - cex * bey;
+    const cd = cex * dey - dex * cey;
+    const da = dex * aey - aex * dey;
+    const ac = aex * cey - cex * aey;
+    const bd = bex * dey - dex * bey;
+
+    const abc = aez * bc - bez * ac + cez * ab;
+    const bcd = bez * cd - cez * bd + dez * bc;
+    const cda = cez * da + dez * ac + aez * cd;
+    const dab = dez * ab + aez * bd + bez * da;
+
+    const alift = aex * aex + aey * aey + aez * aez;
+    const blift = bex * bex + bey * bey + bez * bez;
+    const clift = cex * cex + cey * cey + cez * cez;
+    const dlift = dex * dex + dey * dey + dez * dez;
+
+    return (clift * dab - dlift * abc) + (alift * bcd - blift * cda);
+}
+
+exports.insphere = insphere;
+exports.inspherefast = inspherefast;
+
+}));
diff --git a/tools/ui/node_modules/robust-predicates/umd/insphere.min.js b/tools/ui/node_modules/robust-predicates/umd/insphere.min.js
new file mode 100644
index 0000000000000000000000000000000000000000..8540f6d7f9ada5238fa7c1646b830bcdcc3ad424
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/umd/insphere.min.js
@@ -0,0 +1 @@
+!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((t="undefined"!=typeof globalThis?globalThis:t||self).predicates={})}(this,function(t){"use strict";const n=11102230246251565e-32,e=134217729,r=(3+8*n)*n;function o(t,n,e,r,o){let a,s,f,u,i=n[0],c=r[0],h=0,b=0;c>i==c>-i?(a=i,i=n[++h]):(a=c,c=r[++b]);let l=0;if(hi==c>-i?(s=i+a,f=a-(s-i),i=n[++h]):(s=c+a,f=a-(s-c),c=r[++b]),a=s,0!==f&&(o[l++]=f);hi==c>-i?(s=a+i,u=s-a,f=a-(s-u)+(i-u),i=n[++h]):(s=a+c,u=s-a,f=a-(s-u)+(c-u),c=r[++b]),a=s,0!==f&&(o[l++]=f);for(;h=Rt||-Qt>=Rt)return Qt;if(xt=t-Ct,st=t-(Ct+xt)+(xt-U),xt=n-Ht,ct=n-(Ht+xt)+(xt-V),xt=s-Lt,Mt=s-(Lt+xt)+(xt-W),xt=u-Dt,ft=u-(Dt+xt)+(xt-U),xt=K-It,ht=K-(It+xt)+(xt-V),xt=L-Nt,dt=L-(Nt+xt)+(xt-W),xt=N-Et,ut=N-(Et+xt)+(xt-U),xt=O-Jt,bt=O-(Jt+xt)+(xt-V),xt=P-Ot,pt=P-(Ot+xt)+(xt-W),xt=Q-Gt,it=Q-(Gt+xt)+(xt-U),xt=R-Kt,lt=R-(Kt+xt)+(xt-V),xt=S-Pt,yt=S-(Pt+xt)+(xt-W),0===st&&0===ct&&0===Mt&&0===ft&&0===ht&&0===dt&&0===ut&&0===bt&&0===pt&&0===it&&0===lt&&0===yt)return Qt;Rt=8751425667295619e-46*X+r*Math.abs(Qt);const St=Ct*ht+It*st-(Ht*ft+Dt*ct),Ut=Dt*bt+Jt*ft-(It*ut+Et*ht),Vt=Et*lt+Kt*ut-(Jt*it+Gt*bt),Wt=Gt*ct+Ht*it-(Kt*st+Ct*lt),Xt=Ct*bt+Jt*st-(Ht*ut+Et*ct),Yt=Dt*lt+Kt*ft-(It*it+Gt*ht);return Qt+=(Dt*Dt+It*It+Nt*Nt)*(Ot*Wt+Pt*Xt+Lt*Vt+(pt*nt+yt*ot+Mt*tt))+(Gt*Gt+Kt*Kt+Pt*Pt)*(Lt*Ut-Nt*Xt+Ot*St+(Mt*_-dt*ot+pt*Y))-((Ct*Ct+Ht*Ht+Lt*Lt)*(Nt*Vt-Ot*Yt+Pt*Ut+(dt*tt-pt*at+yt*_))+(Et*Et+Jt*Jt+Ot*Ot)*(Pt*St+Lt*Yt+Nt*Wt+(yt*Y+Mt*at+dt*nt)))+2*((Dt*ft+It*ht+Nt*dt)*(Ot*nt+Pt*ot+Lt*tt)+(Gt*it+Kt*lt+Pt*yt)*(Lt*_-Nt*ot+Ot*Y)-((Ct*st+Ht*ct+Lt*Mt)*(Nt*tt-Ot*at+Pt*_)+(Et*ut+Jt*bt+Ot*pt)*(Pt*Y+Lt*at+Nt*nt))),Qt>=Rt||-Qt>=Rt?Qt:function(t,n,r,o,s,f,u,K,L,N,O,P,Q,R,S){let U,V,W,X,Y,_,tt,nt,et,rt,ot,at,st,ft;rt=t*s,V=e*t,W=V-(V-t),X=t-W,V=e*s,Y=V-(V-s),_=s-Y,ot=X*_-(rt-W*Y-X*Y-W*_),at=o*n,V=e*o,W=V-(V-o),X=o-W,V=e*n,Y=V-(V-n),_=n-Y,st=X*_-(at-W*Y-X*Y-W*_),tt=ot-st,U=ot-tt,i[0]=ot-(tt+U)+(U-st),nt=rt+tt,U=nt-rt,et=rt-(nt-U)+(tt-U),tt=et-at,U=et-tt,i[1]=et-(tt+U)+(U-at),ft=nt+tt,U=ft-nt,i[2]=nt-(ft-U)+(tt-U),i[3]=ft,rt=o*K,V=e*o,W=V-(V-o),X=o-W,V=e*K,Y=V-(V-K),_=K-Y,ot=X*_-(rt-W*Y-X*Y-W*_),at=u*s,V=e*u,W=V-(V-u),X=u-W,V=e*s,Y=V-(V-s),_=s-Y,st=X*_-(at-W*Y-X*Y-W*_),tt=ot-st,U=ot-tt,c[0]=ot-(tt+U)+(U-st),nt=rt+tt,U=nt-rt,et=rt-(nt-U)+(tt-U),tt=et-at,U=et-tt,c[1]=et-(tt+U)+(U-at),ft=nt+tt,U=ft-nt,c[2]=nt-(ft-U)+(tt-U),c[3]=ft,rt=u*O,V=e*u,W=V-(V-u),X=u-W,V=e*O,Y=V-(V-O),_=O-Y,ot=X*_-(rt-W*Y-X*Y-W*_),at=N*K,V=e*N,W=V-(V-N),X=N-W,V=e*K,Y=V-(V-K),_=K-Y,st=X*_-(at-W*Y-X*Y-W*_),tt=ot-st,U=ot-tt,h[0]=ot-(tt+U)+(U-st),nt=rt+tt,U=nt-rt,et=rt-(nt-U)+(tt-U),tt=et-at,U=et-tt,h[1]=et-(tt+U)+(U-at),ft=nt+tt,U=ft-nt,h[2]=nt-(ft-U)+(tt-U),h[3]=ft,rt=N*R,V=e*N,W=V-(V-N),X=N-W,V=e*R,Y=V-(V-R),_=R-Y,ot=X*_-(rt-W*Y-X*Y-W*_),at=Q*O,V=e*Q,W=V-(V-Q),X=Q-W,V=e*O,Y=V-(V-O),_=O-Y,st=X*_-(at-W*Y-X*Y-W*_),tt=ot-st,U=ot-tt,b[0]=ot-(tt+U)+(U-st),nt=rt+tt,U=nt-rt,et=rt-(nt-U)+(tt-U),tt=et-at,U=et-tt,b[1]=et-(tt+U)+(U-at),ft=nt+tt,U=ft-nt,b[2]=nt-(ft-U)+(tt-U),b[3]=ft,rt=Q*n,V=e*Q,W=V-(V-Q),X=Q-W,V=e*n,Y=V-(V-n),_=n-Y,ot=X*_-(rt-W*Y-X*Y-W*_),at=t*R,V=e*t,W=V-(V-t),X=t-W,V=e*R,Y=V-(V-R),_=R-Y,st=X*_-(at-W*Y-X*Y-W*_),tt=ot-st,U=ot-tt,l[0]=ot-(tt+U)+(U-st),nt=rt+tt,U=nt-rt,et=rt-(nt-U)+(tt-U),tt=et-at,U=et-tt,l[1]=et-(tt+U)+(U-at),ft=nt+tt,U=ft-nt,l[2]=nt-(ft-U)+(tt-U),l[3]=ft,rt=t*K,V=e*t,W=V-(V-t),X=t-W,V=e*K,Y=V-(V-K),_=K-Y,ot=X*_-(rt-W*Y-X*Y-W*_),at=u*n,V=e*u,W=V-(V-u),X=u-W,V=e*n,Y=V-(V-n),_=n-Y,st=X*_-(at-W*Y-X*Y-W*_),tt=ot-st,U=ot-tt,M[0]=ot-(tt+U)+(U-st),nt=rt+tt,U=nt-rt,et=rt-(nt-U)+(tt-U),tt=et-at,U=et-tt,M[1]=et-(tt+U)+(U-at),ft=nt+tt,U=ft-nt,M[2]=nt-(ft-U)+(tt-U),M[3]=ft,rt=o*O,V=e*o,W=V-(V-o),X=o-W,V=e*O,Y=V-(V-O),_=O-Y,ot=X*_-(rt-W*Y-X*Y-W*_),at=N*s,V=e*N,W=V-(V-N),X=N-W,V=e*s,Y=V-(V-s),_=s-Y,st=X*_-(at-W*Y-X*Y-W*_),tt=ot-st,U=ot-tt,d[0]=ot-(tt+U)+(U-st),nt=rt+tt,U=nt-rt,et=rt-(nt-U)+(tt-U),tt=et-at,U=et-tt,d[1]=et-(tt+U)+(U-at),ft=nt+tt,U=ft-nt,d[2]=nt-(ft-U)+(tt-U),d[3]=ft,rt=u*R,V=e*u,W=V-(V-u),X=u-W,V=e*R,Y=V-(V-R),_=R-Y,ot=X*_-(rt-W*Y-X*Y-W*_),at=Q*K,V=e*Q,W=V-(V-Q),X=Q-W,V=e*K,Y=V-(V-K),_=K-Y,st=X*_-(at-W*Y-X*Y-W*_),tt=ot-st,U=ot-tt,p[0]=ot-(tt+U)+(U-st),nt=rt+tt,U=nt-rt,et=rt-(nt-U)+(tt-U),tt=et-at,U=et-tt,p[1]=et-(tt+U)+(U-at),ft=nt+tt,U=ft-nt,p[2]=nt-(ft-U)+(tt-U),p[3]=ft,rt=N*n,V=e*N,W=V-(V-N),X=N-W,V=e*n,Y=V-(V-n),_=n-Y,ot=X*_-(rt-W*Y-X*Y-W*_),at=t*O,V=e*t,W=V-(V-t),X=t-W,V=e*O,Y=V-(V-O),_=O-Y,st=X*_-(at-W*Y-X*Y-W*_),tt=ot-st,U=ot-tt,y[0]=ot-(tt+U)+(U-st),nt=rt+tt,U=nt-rt,et=rt-(nt-U)+(tt-U),tt=et-at,U=et-tt,y[1]=et-(tt+U)+(U-at),ft=nt+tt,U=ft-nt,y[2]=nt-(ft-U)+(tt-U),y[3]=ft,rt=Q*s,V=e*Q,W=V-(V-Q),X=Q-W,V=e*s,Y=V-(V-s),_=s-Y,ot=X*_-(rt-W*Y-X*Y-W*_),at=o*R,V=e*o,W=V-(V-o),X=o-W,V=e*R,Y=V-(V-R),_=R-Y,st=X*_-(at-W*Y-X*Y-W*_),tt=ot-st,U=ot-tt,x[0]=ot-(tt+U)+(U-st),nt=rt+tt,U=nt-rt,et=rt-(nt-U)+(tt-U),tt=et-at,U=et-tt,x[1]=et-(tt+U)+(U-at),ft=nt+tt,U=ft-nt,x[2]=nt-(ft-U)+(tt-U),x[3]=ft;const ut=Z(i,c,M,L,r,-f,g),it=Z(c,h,d,P,f,-L,m),ct=Z(h,b,p,S,L,-P,T),ht=Z(b,l,y,r,P,-S,j),bt=Z(l,i,x,f,S,-r,w),lt=Z(i,d,y,P,r,f,A),Mt=Z(c,p,x,S,f,L,F),dt=Z(h,y,M,r,L,P,k),pt=Z(b,x,d,f,P,S,q),yt=Z(l,M,p,L,S,r,v),xt=a($(ct,T,Mt,F,pt,q,it,m,t,n,r,z),z,$(ht,j,dt,k,yt,v,ct,T,o,s,f,B),B,a($(bt,w,pt,q,lt,A,ht,j,u,K,L,C),C,$(ut,g,yt,v,Mt,F,bt,w,N,O,P,D),D,$(it,m,lt,A,dt,k,ut,g,Q,R,S,E),E,H,I),I,G,J);return J[xt-1]}(t,n,s,u,K,L,N,O,P,Q,R,S,U,V,W)}t.insphere=function(t,n,e,r,o,a,s,f,u,i,c,h,b,l,M){const d=t-b,p=r-b,y=s-b,x=i-b,g=n-l,m=o-l,T=f-l,j=c-l,w=e-M,A=a-M,F=u-M,k=h-M,q=d*m,v=p*g,z=q-v,B=p*T,C=y*m,D=B-C,E=y*j,G=x*T,H=E-G,I=x*g,J=d*j,K=I-J,L=d*T,N=y*g,O=L-N,P=p*j,Q=x*m,R=P-Q,S=d*d+g*g+w*w,U=p*p+m*m+A*A,V=y*y+T*T+F*F,W=x*x+j*j+k*k,X=V*(k*z+w*R+A*K)-W*(w*D-A*O+F*z)+(S*(A*H-F*R+k*D)-U*(F*K+k*O+w*H)),Y=Math.abs(w),Z=Math.abs(A),$=Math.abs(F),_=Math.abs(k),tt=Math.abs(q)+Math.abs(v),nt=Math.abs(B)+Math.abs(C),et=Math.abs(E)+Math.abs(G),rt=Math.abs(I)+Math.abs(J),at=Math.abs(L)+Math.abs(N),st=Math.abs(P)+Math.abs(Q),ft=(et*Z+st*$+nt*_)*S+(rt*$+at*_+et*Y)*U+(tt*_+st*Y+rt*Z)*V+(nt*Y+at*Z+tt*$)*W,ut=17763568394002532e-31*ft;return X>ut||-X>ut?X:-ot(t,n,e,r,o,a,s,f,u,i,c,h,b,l,M,ft)},t.inspherefast=function(t,n,e,r,o,a,s,f,u,i,c,h,b,l,M){const d=t-b,p=r-b,y=s-b,x=i-b,g=n-l,m=o-l,T=f-l,j=c-l,w=e-M,A=a-M,F=u-M,k=h-M,q=d*m-p*g,v=p*T-y*m,z=y*j-x*T,B=x*g-d*j,C=d*T-y*g,D=p*j-x*m;return(y*y+T*T+F*F)*(k*q+w*D+A*B)-(x*x+j*j+k*k)*(w*v-A*C+F*q)+((d*d+g*g+w*w)*(A*z-F*D+k*v)-(p*p+m*m+A*A)*(F*B+k*C+w*z))}});
diff --git a/tools/ui/node_modules/robust-predicates/umd/orient2d.js b/tools/ui/node_modules/robust-predicates/umd/orient2d.js
new file mode 100644
index 0000000000000000000000000000000000000000..616377db7e27568b635f7eac10a3afadaeae3bf3
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/umd/orient2d.js
@@ -0,0 +1,280 @@
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+typeof define === 'function' && define.amd ? define(['exports'], factory) :
+(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.predicates = {}));
+})(this, (function (exports) { 'use strict';
+
+const epsilon = 1.1102230246251565e-16;
+const splitter = 134217729;
+const resulterrbound = (3 + 8 * epsilon) * epsilon;
+
+// fast_expansion_sum_zeroelim routine from original code
+function sum(elen, e, flen, f, h) {
+    let Q, Qnew, hh, bvirt;
+    let enow = e[0];
+    let fnow = f[0];
+    let eindex = 0;
+    let findex = 0;
+    if ((fnow > enow) === (fnow > -enow)) {
+        Q = enow;
+        enow = e[++eindex];
+    } else {
+        Q = fnow;
+        fnow = f[++findex];
+    }
+    let hindex = 0;
+    if (eindex < elen && findex < flen) {
+        if ((fnow > enow) === (fnow > -enow)) {
+            Qnew = enow + Q;
+            hh = Q - (Qnew - enow);
+            enow = e[++eindex];
+        } else {
+            Qnew = fnow + Q;
+            hh = Q - (Qnew - fnow);
+            fnow = f[++findex];
+        }
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        while (eindex < elen && findex < flen) {
+            if ((fnow > enow) === (fnow > -enow)) {
+                Qnew = Q + enow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (enow - bvirt);
+                enow = e[++eindex];
+            } else {
+                Qnew = Q + fnow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+                fnow = f[++findex];
+            }
+            Q = Qnew;
+            if (hh !== 0) {
+                h[hindex++] = hh;
+            }
+        }
+    }
+    while (eindex < elen) {
+        Qnew = Q + enow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (enow - bvirt);
+        enow = e[++eindex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    while (findex < flen) {
+        Qnew = Q + fnow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+        fnow = f[++findex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+function estimate(elen, e) {
+    let Q = e[0];
+    for (let i = 1; i < elen; i++) Q += e[i];
+    return Q;
+}
+
+function vec(n) {
+    return new Float64Array(n);
+}
+
+const ccwerrboundA = (3 + 16 * epsilon) * epsilon;
+const ccwerrboundB = (2 + 12 * epsilon) * epsilon;
+const ccwerrboundC = (9 + 64 * epsilon) * epsilon * epsilon;
+
+const B = vec(4);
+const C1 = vec(8);
+const C2 = vec(12);
+const D = vec(16);
+const u = vec(4);
+
+function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
+    let acxtail, acytail, bcxtail, bcytail;
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    const acx = ax - cx;
+    const bcx = bx - cx;
+    const acy = ay - cy;
+    const bcy = by - cy;
+
+    s1 = acx * bcy;
+    c = splitter * acx;
+    ahi = c - (c - acx);
+    alo = acx - ahi;
+    c = splitter * bcy;
+    bhi = c - (c - bcy);
+    blo = bcy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acy * bcx;
+    c = splitter * acy;
+    ahi = c - (c - acy);
+    alo = acy - ahi;
+    c = splitter * bcx;
+    bhi = c - (c - bcx);
+    blo = bcx - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    B[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    B[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    B[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    B[3] = u3;
+
+    let det = estimate(4, B);
+    let errbound = ccwerrboundB * detsum;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - acx;
+    acxtail = ax - (acx + bvirt) + (bvirt - cx);
+    bvirt = bx - bcx;
+    bcxtail = bx - (bcx + bvirt) + (bvirt - cx);
+    bvirt = ay - acy;
+    acytail = ay - (acy + bvirt) + (bvirt - cy);
+    bvirt = by - bcy;
+    bcytail = by - (bcy + bvirt) + (bvirt - cy);
+
+    if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) {
+        return det;
+    }
+
+    errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);
+    det += (acx * bcytail + bcy * acxtail) - (acy * bcxtail + bcx * acytail);
+    if (det >= errbound || -det >= errbound) return det;
+
+    s1 = acxtail * bcy;
+    c = splitter * acxtail;
+    ahi = c - (c - acxtail);
+    alo = acxtail - ahi;
+    c = splitter * bcy;
+    bhi = c - (c - bcy);
+    blo = bcy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acytail * bcx;
+    c = splitter * acytail;
+    ahi = c - (c - acytail);
+    alo = acytail - ahi;
+    c = splitter * bcx;
+    bhi = c - (c - bcx);
+    blo = bcx - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u[3] = u3;
+    const C1len = sum(4, B, 4, u, C1);
+
+    s1 = acx * bcytail;
+    c = splitter * acx;
+    ahi = c - (c - acx);
+    alo = acx - ahi;
+    c = splitter * bcytail;
+    bhi = c - (c - bcytail);
+    blo = bcytail - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acy * bcxtail;
+    c = splitter * acy;
+    ahi = c - (c - acy);
+    alo = acy - ahi;
+    c = splitter * bcxtail;
+    bhi = c - (c - bcxtail);
+    blo = bcxtail - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u[3] = u3;
+    const C2len = sum(C1len, C1, 4, u, C2);
+
+    s1 = acxtail * bcytail;
+    c = splitter * acxtail;
+    ahi = c - (c - acxtail);
+    alo = acxtail - ahi;
+    c = splitter * bcytail;
+    bhi = c - (c - bcytail);
+    blo = bcytail - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acytail * bcxtail;
+    c = splitter * acytail;
+    ahi = c - (c - acytail);
+    alo = acytail - ahi;
+    c = splitter * bcxtail;
+    bhi = c - (c - bcxtail);
+    blo = bcxtail - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u[3] = u3;
+    const Dlen = sum(C2len, C2, 4, u, D);
+
+    return D[Dlen - 1];
+}
+
+function orient2d(ax, ay, bx, by, cx, cy) {
+    const detleft = (ay - cy) * (bx - cx);
+    const detright = (ax - cx) * (by - cy);
+    const det = detleft - detright;
+
+    const detsum = Math.abs(detleft + detright);
+    if (Math.abs(det) >= ccwerrboundA * detsum) return det;
+
+    return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum);
+}
+
+function orient2dfast(ax, ay, bx, by, cx, cy) {
+    return (ay - cy) * (bx - cx) - (ax - cx) * (by - cy);
+}
+
+exports.orient2d = orient2d;
+exports.orient2dfast = orient2dfast;
+
+}));
diff --git a/tools/ui/node_modules/robust-predicates/umd/orient2d.min.js b/tools/ui/node_modules/robust-predicates/umd/orient2d.min.js
new file mode 100644
index 0000000000000000000000000000000000000000..b99fa7b79aaf51a5975fef045f7197d70f13364a
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/umd/orient2d.min.js
@@ -0,0 +1 @@
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).predicates={})}(this,function(t){"use strict";const e=11102230246251565e-32,n=134217729,o=(3+8*e)*e;function r(t,e,n,o,r){let f,i,u,s,c=e[0],a=o[0],l=0,d=0;a>c==a>-c?(f=c,c=e[++l]):(f=a,a=o[++d]);let p=0;if(lc==a>-c?(i=c+f,u=f-(i-c),c=e[++l]):(i=a+f,u=f-(i-a),a=o[++d]),f=i,0!==u&&(r[p++]=u);lc==a>-c?(i=f+c,s=i-f,u=f-(i-s)+(c-s),c=e[++l]):(i=f+a,s=i-f,u=f-(i-s)+(a-s),a=o[++d]),f=i,0!==u&&(r[p++]=u);for(;l=33306690738754716e-32*x?y:-function(t,e,f,l,d,p,b){let h,y,x,M,g,m,T,j,w,A,F,k,q,v,z,B,C,D;const E=t-d,G=f-d,H=e-p,I=l-p;v=E*I,m=n*E,T=m-(m-E),j=E-T,m=n*I,w=m-(m-I),A=I-w,z=j*A-(v-T*w-j*w-T*A),B=H*G,m=n*H,T=m-(m-H),j=H-T,m=n*G,w=m-(m-G),A=G-w,C=j*A-(B-T*w-j*w-T*A),F=z-C,g=z-F,i[0]=z-(F+g)+(g-C),k=v+F,g=k-v,q=v-(k-g)+(F-g),F=q-B,g=q-F,i[1]=q-(F+g)+(g-B),D=k+F,g=D-k,i[2]=k-(D-g)+(F-g),i[3]=D;let J=function(t,e){let n=e[0];for(let o=1;o=K||-J>=K)return J;if(g=t-E,h=t-(E+g)+(g-d),g=f-G,x=f-(G+g)+(g-d),g=e-H,y=e-(H+g)+(g-p),g=l-I,M=l-(I+g)+(g-p),0===h&&0===y&&0===x&&0===M)return J;if(K=11093356479670487e-47*b+o*Math.abs(J),J+=E*M+I*h-(H*x+G*y),J>=K||-J>=K)return J;v=h*I,m=n*h,T=m-(m-h),j=h-T,m=n*I,w=m-(m-I),A=I-w,z=j*A-(v-T*w-j*w-T*A),B=y*G,m=n*y,T=m-(m-y),j=y-T,m=n*G,w=m-(m-G),A=G-w,C=j*A-(B-T*w-j*w-T*A),F=z-C,g=z-F,a[0]=z-(F+g)+(g-C),k=v+F,g=k-v,q=v-(k-g)+(F-g),F=q-B,g=q-F,a[1]=q-(F+g)+(g-B),D=k+F,g=D-k,a[2]=k-(D-g)+(F-g),a[3]=D;const L=r(4,i,4,a,u);v=E*M,m=n*E,T=m-(m-E),j=E-T,m=n*M,w=m-(m-M),A=M-w,z=j*A-(v-T*w-j*w-T*A),B=H*x,m=n*H,T=m-(m-H),j=H-T,m=n*x,w=m-(m-x),A=x-w,C=j*A-(B-T*w-j*w-T*A),F=z-C,g=z-F,a[0]=z-(F+g)+(g-C),k=v+F,g=k-v,q=v-(k-g)+(F-g),F=q-B,g=q-F,a[1]=q-(F+g)+(g-B),D=k+F,g=D-k,a[2]=k-(D-g)+(F-g),a[3]=D;const N=r(L,u,4,a,s);v=h*M,m=n*h,T=m-(m-h),j=h-T,m=n*M,w=m-(m-M),A=M-w,z=j*A-(v-T*w-j*w-T*A),B=y*x,m=n*y,T=m-(m-y),j=y-T,m=n*x,w=m-(m-x),A=x-w,C=j*A-(B-T*w-j*w-T*A),F=z-C,g=z-F,a[0]=z-(F+g)+(g-C),k=v+F,g=k-v,q=v-(k-g)+(F-g),F=q-B,g=q-F,a[1]=q-(F+g)+(g-B),D=k+F,g=D-k,a[2]=k-(D-g)+(F-g),a[3]=D;const O=r(N,s,4,a,c);return c[O-1]}(t,e,f,l,d,p,x)},t.orient2dfast=function(t,e,n,o,r,f){return(e-f)*(n-r)-(t-r)*(o-f)}});
diff --git a/tools/ui/node_modules/robust-predicates/umd/orient3d.js b/tools/ui/node_modules/robust-predicates/umd/orient3d.js
new file mode 100644
index 0000000000000000000000000000000000000000..04bc77a5711be65fa37352fd5684cc24925dea9e
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/umd/orient3d.js
@@ -0,0 +1,598 @@
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+typeof define === 'function' && define.amd ? define(['exports'], factory) :
+(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.predicates = {}));
+})(this, (function (exports) { 'use strict';
+
+const epsilon = 1.1102230246251565e-16;
+const splitter = 134217729;
+const resulterrbound = (3 + 8 * epsilon) * epsilon;
+
+// fast_expansion_sum_zeroelim routine from original code
+function sum(elen, e, flen, f, h) {
+    let Q, Qnew, hh, bvirt;
+    let enow = e[0];
+    let fnow = f[0];
+    let eindex = 0;
+    let findex = 0;
+    if ((fnow > enow) === (fnow > -enow)) {
+        Q = enow;
+        enow = e[++eindex];
+    } else {
+        Q = fnow;
+        fnow = f[++findex];
+    }
+    let hindex = 0;
+    if (eindex < elen && findex < flen) {
+        if ((fnow > enow) === (fnow > -enow)) {
+            Qnew = enow + Q;
+            hh = Q - (Qnew - enow);
+            enow = e[++eindex];
+        } else {
+            Qnew = fnow + Q;
+            hh = Q - (Qnew - fnow);
+            fnow = f[++findex];
+        }
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        while (eindex < elen && findex < flen) {
+            if ((fnow > enow) === (fnow > -enow)) {
+                Qnew = Q + enow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (enow - bvirt);
+                enow = e[++eindex];
+            } else {
+                Qnew = Q + fnow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+                fnow = f[++findex];
+            }
+            Q = Qnew;
+            if (hh !== 0) {
+                h[hindex++] = hh;
+            }
+        }
+    }
+    while (eindex < elen) {
+        Qnew = Q + enow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (enow - bvirt);
+        enow = e[++eindex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    while (findex < flen) {
+        Qnew = Q + fnow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+        fnow = f[++findex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+// scale_expansion_zeroelim routine from oritinal code
+function scale(elen, e, b, h) {
+    let Q, sum, hh, product1, product0;
+    let bvirt, c, ahi, alo, bhi, blo;
+
+    c = splitter * b;
+    bhi = c - (c - b);
+    blo = b - bhi;
+    let enow = e[0];
+    Q = enow * b;
+    c = splitter * enow;
+    ahi = c - (c - enow);
+    alo = enow - ahi;
+    hh = alo * blo - (Q - ahi * bhi - alo * bhi - ahi * blo);
+    let hindex = 0;
+    if (hh !== 0) {
+        h[hindex++] = hh;
+    }
+    for (let i = 1; i < elen; i++) {
+        enow = e[i];
+        product1 = enow * b;
+        c = splitter * enow;
+        ahi = c - (c - enow);
+        alo = enow - ahi;
+        product0 = alo * blo - (product1 - ahi * bhi - alo * bhi - ahi * blo);
+        sum = Q + product0;
+        bvirt = sum - Q;
+        hh = Q - (sum - bvirt) + (product0 - bvirt);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        Q = product1 + sum;
+        hh = sum - (Q - product1);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+function estimate(elen, e) {
+    let Q = e[0];
+    for (let i = 1; i < elen; i++) Q += e[i];
+    return Q;
+}
+
+function vec(n) {
+    return new Float64Array(n);
+}
+
+const o3derrboundA = (7 + 56 * epsilon) * epsilon;
+const o3derrboundB = (3 + 28 * epsilon) * epsilon;
+const o3derrboundC = (26 + 288 * epsilon) * epsilon * epsilon;
+
+const bc = vec(4);
+const ca = vec(4);
+const ab = vec(4);
+const at_b = vec(4);
+const at_c = vec(4);
+const bt_c = vec(4);
+const bt_a = vec(4);
+const ct_a = vec(4);
+const ct_b = vec(4);
+const bct = vec(8);
+const cat = vec(8);
+const abt = vec(8);
+const u = vec(4);
+
+const _8 = vec(8);
+const _8b = vec(8);
+const _16 = vec(16);
+const _12 = vec(12);
+
+let fin = vec(192);
+let fin2 = vec(192);
+
+function finadd(finlen, alen, a) {
+    finlen = sum(finlen, fin, alen, a, fin2);
+    const tmp = fin; fin = fin2; fin2 = tmp;
+    return finlen;
+}
+
+function tailinit(xtail, ytail, ax, ay, bx, by, a, b) {
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3, negate;
+    if (xtail === 0) {
+        if (ytail === 0) {
+            a[0] = 0;
+            b[0] = 0;
+            return 1;
+        }
+        negate = -ytail;
+        s1 = negate * ax;
+        c = splitter * negate;
+        ahi = c - (c - negate);
+        alo = negate - ahi;
+        c = splitter * ax;
+        bhi = c - (c - ax);
+        blo = ax - bhi;
+        a[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+        a[1] = s1;
+        s1 = ytail * bx;
+        c = splitter * ytail;
+        ahi = c - (c - ytail);
+        alo = ytail - ahi;
+        c = splitter * bx;
+        bhi = c - (c - bx);
+        blo = bx - bhi;
+        b[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+        b[1] = s1;
+        return 2;
+    }
+    if (ytail === 0) {
+        s1 = xtail * ay;
+        c = splitter * xtail;
+        ahi = c - (c - xtail);
+        alo = xtail - ahi;
+        c = splitter * ay;
+        bhi = c - (c - ay);
+        blo = ay - bhi;
+        a[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+        a[1] = s1;
+        negate = -xtail;
+        s1 = negate * by;
+        c = splitter * negate;
+        ahi = c - (c - negate);
+        alo = negate - ahi;
+        c = splitter * by;
+        bhi = c - (c - by);
+        blo = by - bhi;
+        b[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+        b[1] = s1;
+        return 2;
+    }
+    s1 = xtail * ay;
+    c = splitter * xtail;
+    ahi = c - (c - xtail);
+    alo = xtail - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ytail * ax;
+    c = splitter * ytail;
+    ahi = c - (c - ytail);
+    alo = ytail - ahi;
+    c = splitter * ax;
+    bhi = c - (c - ax);
+    blo = ax - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    a[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    a[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    a[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    a[3] = u3;
+    s1 = ytail * bx;
+    c = splitter * ytail;
+    ahi = c - (c - ytail);
+    alo = ytail - ahi;
+    c = splitter * bx;
+    bhi = c - (c - bx);
+    blo = bx - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = xtail * by;
+    c = splitter * xtail;
+    ahi = c - (c - xtail);
+    alo = xtail - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    b[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    b[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    b[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    b[3] = u3;
+    return 4;
+}
+
+function tailadd(finlen, a, b, k, z) {
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, u3;
+    s1 = a * b;
+    c = splitter * a;
+    ahi = c - (c - a);
+    alo = a - ahi;
+    c = splitter * b;
+    bhi = c - (c - b);
+    blo = b - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    c = splitter * k;
+    bhi = c - (c - k);
+    blo = k - bhi;
+    _i = s0 * k;
+    c = splitter * s0;
+    ahi = c - (c - s0);
+    alo = s0 - ahi;
+    u[0] = alo * blo - (_i - ahi * bhi - alo * bhi - ahi * blo);
+    _j = s1 * k;
+    c = splitter * s1;
+    ahi = c - (c - s1);
+    alo = s1 - ahi;
+    _0 = alo * blo - (_j - ahi * bhi - alo * bhi - ahi * blo);
+    _k = _i + _0;
+    bvirt = _k - _i;
+    u[1] = _i - (_k - bvirt) + (_0 - bvirt);
+    u3 = _j + _k;
+    u[2] = _k - (u3 - _j);
+    u[3] = u3;
+    finlen = finadd(finlen, 4, u);
+    if (z !== 0) {
+        c = splitter * z;
+        bhi = c - (c - z);
+        blo = z - bhi;
+        _i = s0 * z;
+        c = splitter * s0;
+        ahi = c - (c - s0);
+        alo = s0 - ahi;
+        u[0] = alo * blo - (_i - ahi * bhi - alo * bhi - ahi * blo);
+        _j = s1 * z;
+        c = splitter * s1;
+        ahi = c - (c - s1);
+        alo = s1 - ahi;
+        _0 = alo * blo - (_j - ahi * bhi - alo * bhi - ahi * blo);
+        _k = _i + _0;
+        bvirt = _k - _i;
+        u[1] = _i - (_k - bvirt) + (_0 - bvirt);
+        u3 = _j + _k;
+        u[2] = _k - (u3 - _j);
+        u[3] = u3;
+        finlen = finadd(finlen, 4, u);
+    }
+    return finlen;
+}
+
+function orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent) {
+    let finlen;
+    let adxtail, bdxtail, cdxtail;
+    let adytail, bdytail, cdytail;
+    let adztail, bdztail, cdztail;
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+    const adz = az - dz;
+    const bdz = bz - dz;
+    const cdz = cz - dz;
+
+    s1 = bdx * cdy;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cdx * bdy;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bc[3] = u3;
+    s1 = cdx * ady;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = adx * cdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ca[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ca[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ca[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ca[3] = u3;
+    s1 = adx * bdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bdx * ady;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ab[3] = u3;
+
+    finlen = sum(
+        sum(
+            scale(4, bc, adz, _8), _8,
+            scale(4, ca, bdz, _8b), _8b, _16), _16,
+        scale(4, ab, cdz, _8), _8, fin);
+
+    let det = estimate(finlen, fin);
+    let errbound = o3derrboundB * permanent;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - adx;
+    adxtail = ax - (adx + bvirt) + (bvirt - dx);
+    bvirt = bx - bdx;
+    bdxtail = bx - (bdx + bvirt) + (bvirt - dx);
+    bvirt = cx - cdx;
+    cdxtail = cx - (cdx + bvirt) + (bvirt - dx);
+    bvirt = ay - ady;
+    adytail = ay - (ady + bvirt) + (bvirt - dy);
+    bvirt = by - bdy;
+    bdytail = by - (bdy + bvirt) + (bvirt - dy);
+    bvirt = cy - cdy;
+    cdytail = cy - (cdy + bvirt) + (bvirt - dy);
+    bvirt = az - adz;
+    adztail = az - (adz + bvirt) + (bvirt - dz);
+    bvirt = bz - bdz;
+    bdztail = bz - (bdz + bvirt) + (bvirt - dz);
+    bvirt = cz - cdz;
+    cdztail = cz - (cdz + bvirt) + (bvirt - dz);
+
+    if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 &&
+        adytail === 0 && bdytail === 0 && cdytail === 0 &&
+        adztail === 0 && bdztail === 0 && cdztail === 0) {
+        return det;
+    }
+
+    errbound = o3derrboundC * permanent + resulterrbound * Math.abs(det);
+    det +=
+        adz * (bdx * cdytail + cdy * bdxtail - (bdy * cdxtail + cdx * bdytail)) + adztail * (bdx * cdy - bdy * cdx) +
+        bdz * (cdx * adytail + ady * cdxtail - (cdy * adxtail + adx * cdytail)) + bdztail * (cdx * ady - cdy * adx) +
+        cdz * (adx * bdytail + bdy * adxtail - (ady * bdxtail + bdx * adytail)) + cdztail * (adx * bdy - ady * bdx);
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    const at_len = tailinit(adxtail, adytail, bdx, bdy, cdx, cdy, at_b, at_c);
+    const bt_len = tailinit(bdxtail, bdytail, cdx, cdy, adx, ady, bt_c, bt_a);
+    const ct_len = tailinit(cdxtail, cdytail, adx, ady, bdx, bdy, ct_a, ct_b);
+
+    const bctlen = sum(bt_len, bt_c, ct_len, ct_b, bct);
+    finlen = finadd(finlen, scale(bctlen, bct, adz, _16), _16);
+
+    const catlen = sum(ct_len, ct_a, at_len, at_c, cat);
+    finlen = finadd(finlen, scale(catlen, cat, bdz, _16), _16);
+
+    const abtlen = sum(at_len, at_b, bt_len, bt_a, abt);
+    finlen = finadd(finlen, scale(abtlen, abt, cdz, _16), _16);
+
+    if (adztail !== 0) {
+        finlen = finadd(finlen, scale(4, bc, adztail, _12), _12);
+        finlen = finadd(finlen, scale(bctlen, bct, adztail, _16), _16);
+    }
+    if (bdztail !== 0) {
+        finlen = finadd(finlen, scale(4, ca, bdztail, _12), _12);
+        finlen = finadd(finlen, scale(catlen, cat, bdztail, _16), _16);
+    }
+    if (cdztail !== 0) {
+        finlen = finadd(finlen, scale(4, ab, cdztail, _12), _12);
+        finlen = finadd(finlen, scale(abtlen, abt, cdztail, _16), _16);
+    }
+
+    if (adxtail !== 0) {
+        if (bdytail !== 0) {
+            finlen = tailadd(finlen, adxtail, bdytail, cdz, cdztail);
+        }
+        if (cdytail !== 0) {
+            finlen = tailadd(finlen, -adxtail, cdytail, bdz, bdztail);
+        }
+    }
+    if (bdxtail !== 0) {
+        if (cdytail !== 0) {
+            finlen = tailadd(finlen, bdxtail, cdytail, adz, adztail);
+        }
+        if (adytail !== 0) {
+            finlen = tailadd(finlen, -bdxtail, adytail, cdz, cdztail);
+        }
+    }
+    if (cdxtail !== 0) {
+        if (adytail !== 0) {
+            finlen = tailadd(finlen, cdxtail, adytail, bdz, bdztail);
+        }
+        if (bdytail !== 0) {
+            finlen = tailadd(finlen, -cdxtail, bdytail, adz, adztail);
+        }
+    }
+
+    return fin[finlen - 1];
+}
+
+function orient3d(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+    const adz = az - dz;
+    const bdz = bz - dz;
+    const cdz = cz - dz;
+
+    const bdxcdy = bdx * cdy;
+    const cdxbdy = cdx * bdy;
+
+    const cdxady = cdx * ady;
+    const adxcdy = adx * cdy;
+
+    const adxbdy = adx * bdy;
+    const bdxady = bdx * ady;
+
+    const det =
+        adz * (bdxcdy - cdxbdy) +
+        bdz * (cdxady - adxcdy) +
+        cdz * (adxbdy - bdxady);
+
+    const permanent =
+        (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * Math.abs(adz) +
+        (Math.abs(cdxady) + Math.abs(adxcdy)) * Math.abs(bdz) +
+        (Math.abs(adxbdy) + Math.abs(bdxady)) * Math.abs(cdz);
+
+    const errbound = o3derrboundA * permanent;
+    if (det > errbound || -det > errbound) {
+        return det;
+    }
+
+    return orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent);
+}
+
+function orient3dfast(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+    const adz = az - dz;
+    const bdz = bz - dz;
+    const cdz = cz - dz;
+
+    return adx * (bdy * cdz - bdz * cdy) +
+        bdx * (cdy * adz - cdz * ady) +
+        cdx * (ady * bdz - adz * bdy);
+}
+
+exports.orient3d = orient3d;
+exports.orient3dfast = orient3dfast;
+
+}));
diff --git a/tools/ui/node_modules/robust-predicates/umd/orient3d.min.js b/tools/ui/node_modules/robust-predicates/umd/orient3d.min.js
new file mode 100644
index 0000000000000000000000000000000000000000..45013978b8d00922e4e0e006e69f57e6c915b666
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/umd/orient3d.min.js
@@ -0,0 +1 @@
+!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((t="undefined"!=typeof globalThis?globalThis:t||self).predicates={})}(this,function(t){"use strict";const n=11102230246251565e-32,e=134217729,o=(3+8*n)*n;function r(t,n,e,o,r){let f,s,u,i,a=n[0],c=o[0],l=0,b=0;c>a==c>-a?(f=a,a=n[++l]):(f=c,c=o[++b]);let h=0;if(la==c>-a?(s=a+f,u=f-(s-a),a=n[++l]):(s=c+f,u=f-(s-c),c=o[++b]),f=s,0!==u&&(r[h++]=u);la==c>-a?(s=f+a,i=s-f,u=f-(s-i)+(a-i),a=n[++l]):(s=f+c,i=s-f,u=f-(s-i)+(c-i),c=o[++b]),f=s,0!==u&&(r[h++]=u);for(;l_||-Z>_?Z:function(t,n,s,g,F,z,B,C,D,E,G,H,I){let J,K,L,N,O,P,Q,R,S,U,V,W,X,Y,Z,$,_,tt,nt,et,ot,rt,ft,st;const ut=t-E,it=g-E,at=B-E,ct=n-G,lt=F-G,bt=C-G,ht=s-H,dt=z-H,Mt=D-H;et=it*bt,W=e*it,X=W-(W-it),Y=it-X,W=e*bt,Z=W-(W-bt),$=bt-Z,ot=Y*$-(et-X*Z-Y*Z-X*$),rt=at*lt,W=e*at,X=W-(W-at),Y=at-X,W=e*lt,Z=W-(W-lt),$=lt-Z,ft=Y*$-(rt-X*Z-Y*Z-X*$),_=ot-ft,V=ot-_,u[0]=ot-(_+V)+(V-ft),tt=et+_,V=tt-et,nt=et-(tt-V)+(_-V),_=nt-rt,V=nt-_,u[1]=nt-(_+V)+(V-rt),st=tt+_,V=st-tt,u[2]=tt-(st-V)+(_-V),u[3]=st,et=at*ct,W=e*at,X=W-(W-at),Y=at-X,W=e*ct,Z=W-(W-ct),$=ct-Z,ot=Y*$-(et-X*Z-Y*Z-X*$),rt=ut*bt,W=e*ut,X=W-(W-ut),Y=ut-X,W=e*bt,Z=W-(W-bt),$=bt-Z,ft=Y*$-(rt-X*Z-Y*Z-X*$),_=ot-ft,V=ot-_,i[0]=ot-(_+V)+(V-ft),tt=et+_,V=tt-et,nt=et-(tt-V)+(_-V),_=nt-rt,V=nt-_,i[1]=nt-(_+V)+(V-rt),st=tt+_,V=st-tt,i[2]=tt-(st-V)+(_-V),i[3]=st,et=ut*lt,W=e*ut,X=W-(W-ut),Y=ut-X,W=e*lt,Z=W-(W-lt),$=lt-Z,ot=Y*$-(et-X*Z-Y*Z-X*$),rt=it*ct,W=e*it,X=W-(W-it),Y=it-X,W=e*ct,Z=W-(W-ct),$=ct-Z,ft=Y*$-(rt-X*Z-Y*Z-X*$),_=ot-ft,V=ot-_,a[0]=ot-(_+V)+(V-ft),tt=et+_,V=tt-et,nt=et-(tt-V)+(_-V),_=nt-rt,V=nt-_,a[1]=nt-(_+V)+(V-rt),st=tt+_,V=st-tt,a[2]=tt-(st-V)+(_-V),a[3]=st,J=r(r(f(4,u,ht,m),m,f(4,i,dt,T),T,j),j,f(4,a,Mt,m),m,A);let pt=function(t,n){let e=n[0];for(let o=1;o=yt||-pt>=yt)return pt;if(V=t-ut,K=t-(ut+V)+(V-E),V=g-it,L=g-(it+V)+(V-E),V=B-at,N=B-(at+V)+(V-E),V=n-ct,O=n-(ct+V)+(V-G),V=F-lt,P=F-(lt+V)+(V-G),V=C-bt,Q=C-(bt+V)+(V-G),V=s-ht,R=s-(ht+V)+(V-H),V=z-dt,S=z-(dt+V)+(V-H),V=D-Mt,U=D-(Mt+V)+(V-H),0===K&&0===L&&0===N&&0===O&&0===P&&0===Q&&0===R&&0===S&&0===U)return pt;if(yt=32047474274603644e-47*I+o*Math.abs(pt),pt+=ht*(it*Q+bt*L-(lt*N+at*P))+R*(it*bt-lt*at)+dt*(at*O+ct*N-(bt*K+ut*Q))+S*(at*ct-bt*ut)+Mt*(ut*P+lt*K-(ct*L+it*O))+U*(ut*lt-ct*it),pt>=yt||-pt>=yt)return pt;const xt=q(K,O,it,lt,at,bt,c,l),gt=q(L,P,at,bt,ut,ct,b,h),mt=q(N,Q,ut,ct,it,lt,d,M),Tt=r(gt,b,mt,M,p);J=k(J,f(Tt,p,ht,j),j);const jt=r(mt,d,xt,l,y);J=k(J,f(jt,y,dt,j),j);const wt=r(xt,c,gt,h,x);return J=k(J,f(wt,x,Mt,j),j),0!==R&&(J=k(J,f(4,u,R,w),w),J=k(J,f(Tt,p,R,j),j)),0!==S&&(J=k(J,f(4,i,S,w),w),J=k(J,f(jt,y,S,j),j)),0!==U&&(J=k(J,f(4,a,U,w),w),J=k(J,f(wt,x,U,j),j)),0!==K&&(0!==P&&(J=v(J,K,P,Mt,U)),0!==Q&&(J=v(J,-K,Q,dt,S))),0!==L&&(0!==Q&&(J=v(J,L,Q,ht,R)),0!==O&&(J=v(J,-L,O,Mt,U))),0!==N&&(0!==O&&(J=v(J,N,O,dt,S)),0!==P&&(J=v(J,-N,P,ht,R))),A[J-1]}(t,n,s,g,F,z,B,C,D,E,G,H,$)},t.orient3dfast=function(t,n,e,o,r,f,s,u,i,a,c,l){const b=n-c,h=r-c,d=u-c,M=e-l,p=f-l,y=i-l;return(t-a)*(h*y-p*d)+(o-a)*(d*M-y*b)+(s-a)*(b*p-M*h)}});
diff --git a/tools/ui/node_modules/robust-predicates/umd/predicates.js b/tools/ui/node_modules/robust-predicates/umd/predicates.js
new file mode 100644
index 0000000000000000000000000000000000000000..c84caae8689cff91c011c6c1f58adc44ca429f34
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/umd/predicates.js
@@ -0,0 +1,2325 @@
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+typeof define === 'function' && define.amd ? define(['exports'], factory) :
+(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.predicates = {}));
+})(this, (function (exports) { 'use strict';
+
+const epsilon = 1.1102230246251565e-16;
+const splitter = 134217729;
+const resulterrbound = (3 + 8 * epsilon) * epsilon;
+
+// fast_expansion_sum_zeroelim routine from original code
+function sum(elen, e, flen, f, h) {
+    let Q, Qnew, hh, bvirt;
+    let enow = e[0];
+    let fnow = f[0];
+    let eindex = 0;
+    let findex = 0;
+    if ((fnow > enow) === (fnow > -enow)) {
+        Q = enow;
+        enow = e[++eindex];
+    } else {
+        Q = fnow;
+        fnow = f[++findex];
+    }
+    let hindex = 0;
+    if (eindex < elen && findex < flen) {
+        if ((fnow > enow) === (fnow > -enow)) {
+            Qnew = enow + Q;
+            hh = Q - (Qnew - enow);
+            enow = e[++eindex];
+        } else {
+            Qnew = fnow + Q;
+            hh = Q - (Qnew - fnow);
+            fnow = f[++findex];
+        }
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        while (eindex < elen && findex < flen) {
+            if ((fnow > enow) === (fnow > -enow)) {
+                Qnew = Q + enow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (enow - bvirt);
+                enow = e[++eindex];
+            } else {
+                Qnew = Q + fnow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+                fnow = f[++findex];
+            }
+            Q = Qnew;
+            if (hh !== 0) {
+                h[hindex++] = hh;
+            }
+        }
+    }
+    while (eindex < elen) {
+        Qnew = Q + enow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (enow - bvirt);
+        enow = e[++eindex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    while (findex < flen) {
+        Qnew = Q + fnow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+        fnow = f[++findex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+function sum_three(alen, a, blen, b, clen, c, tmp, out) {
+    return sum(sum(alen, a, blen, b, tmp), tmp, clen, c, out);
+}
+
+// scale_expansion_zeroelim routine from oritinal code
+function scale(elen, e, b, h) {
+    let Q, sum, hh, product1, product0;
+    let bvirt, c, ahi, alo, bhi, blo;
+
+    c = splitter * b;
+    bhi = c - (c - b);
+    blo = b - bhi;
+    let enow = e[0];
+    Q = enow * b;
+    c = splitter * enow;
+    ahi = c - (c - enow);
+    alo = enow - ahi;
+    hh = alo * blo - (Q - ahi * bhi - alo * bhi - ahi * blo);
+    let hindex = 0;
+    if (hh !== 0) {
+        h[hindex++] = hh;
+    }
+    for (let i = 1; i < elen; i++) {
+        enow = e[i];
+        product1 = enow * b;
+        c = splitter * enow;
+        ahi = c - (c - enow);
+        alo = enow - ahi;
+        product0 = alo * blo - (product1 - ahi * bhi - alo * bhi - ahi * blo);
+        sum = Q + product0;
+        bvirt = sum - Q;
+        hh = Q - (sum - bvirt) + (product0 - bvirt);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        Q = product1 + sum;
+        hh = sum - (Q - product1);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+function negate(elen, e) {
+    for (let i = 0; i < elen; i++) e[i] = -e[i];
+    return elen;
+}
+
+function estimate(elen, e) {
+    let Q = e[0];
+    for (let i = 1; i < elen; i++) Q += e[i];
+    return Q;
+}
+
+function vec(n) {
+    return new Float64Array(n);
+}
+
+const ccwerrboundA = (3 + 16 * epsilon) * epsilon;
+const ccwerrboundB = (2 + 12 * epsilon) * epsilon;
+const ccwerrboundC = (9 + 64 * epsilon) * epsilon * epsilon;
+
+const B = vec(4);
+const C1 = vec(8);
+const C2 = vec(12);
+const D = vec(16);
+const u$2 = vec(4);
+
+function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
+    let acxtail, acytail, bcxtail, bcytail;
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    const acx = ax - cx;
+    const bcx = bx - cx;
+    const acy = ay - cy;
+    const bcy = by - cy;
+
+    s1 = acx * bcy;
+    c = splitter * acx;
+    ahi = c - (c - acx);
+    alo = acx - ahi;
+    c = splitter * bcy;
+    bhi = c - (c - bcy);
+    blo = bcy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acy * bcx;
+    c = splitter * acy;
+    ahi = c - (c - acy);
+    alo = acy - ahi;
+    c = splitter * bcx;
+    bhi = c - (c - bcx);
+    blo = bcx - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    B[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    B[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    B[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    B[3] = u3;
+
+    let det = estimate(4, B);
+    let errbound = ccwerrboundB * detsum;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - acx;
+    acxtail = ax - (acx + bvirt) + (bvirt - cx);
+    bvirt = bx - bcx;
+    bcxtail = bx - (bcx + bvirt) + (bvirt - cx);
+    bvirt = ay - acy;
+    acytail = ay - (acy + bvirt) + (bvirt - cy);
+    bvirt = by - bcy;
+    bcytail = by - (bcy + bvirt) + (bvirt - cy);
+
+    if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) {
+        return det;
+    }
+
+    errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);
+    det += (acx * bcytail + bcy * acxtail) - (acy * bcxtail + bcx * acytail);
+    if (det >= errbound || -det >= errbound) return det;
+
+    s1 = acxtail * bcy;
+    c = splitter * acxtail;
+    ahi = c - (c - acxtail);
+    alo = acxtail - ahi;
+    c = splitter * bcy;
+    bhi = c - (c - bcy);
+    blo = bcy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acytail * bcx;
+    c = splitter * acytail;
+    ahi = c - (c - acytail);
+    alo = acytail - ahi;
+    c = splitter * bcx;
+    bhi = c - (c - bcx);
+    blo = bcx - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u$2[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u$2[3] = u3;
+    const C1len = sum(4, B, 4, u$2, C1);
+
+    s1 = acx * bcytail;
+    c = splitter * acx;
+    ahi = c - (c - acx);
+    alo = acx - ahi;
+    c = splitter * bcytail;
+    bhi = c - (c - bcytail);
+    blo = bcytail - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acy * bcxtail;
+    c = splitter * acy;
+    ahi = c - (c - acy);
+    alo = acy - ahi;
+    c = splitter * bcxtail;
+    bhi = c - (c - bcxtail);
+    blo = bcxtail - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u$2[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u$2[3] = u3;
+    const C2len = sum(C1len, C1, 4, u$2, C2);
+
+    s1 = acxtail * bcytail;
+    c = splitter * acxtail;
+    ahi = c - (c - acxtail);
+    alo = acxtail - ahi;
+    c = splitter * bcytail;
+    bhi = c - (c - bcytail);
+    blo = bcytail - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acytail * bcxtail;
+    c = splitter * acytail;
+    ahi = c - (c - acytail);
+    alo = acytail - ahi;
+    c = splitter * bcxtail;
+    bhi = c - (c - bcxtail);
+    blo = bcxtail - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u$2[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u$2[3] = u3;
+    const Dlen = sum(C2len, C2, 4, u$2, D);
+
+    return D[Dlen - 1];
+}
+
+function orient2d(ax, ay, bx, by, cx, cy) {
+    const detleft = (ay - cy) * (bx - cx);
+    const detright = (ax - cx) * (by - cy);
+    const det = detleft - detright;
+
+    const detsum = Math.abs(detleft + detright);
+    if (Math.abs(det) >= ccwerrboundA * detsum) return det;
+
+    return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum);
+}
+
+function orient2dfast(ax, ay, bx, by, cx, cy) {
+    return (ay - cy) * (bx - cx) - (ax - cx) * (by - cy);
+}
+
+const o3derrboundA = (7 + 56 * epsilon) * epsilon;
+const o3derrboundB = (3 + 28 * epsilon) * epsilon;
+const o3derrboundC = (26 + 288 * epsilon) * epsilon * epsilon;
+
+const bc$2 = vec(4);
+const ca$1 = vec(4);
+const ab$2 = vec(4);
+const at_b = vec(4);
+const at_c = vec(4);
+const bt_c = vec(4);
+const bt_a = vec(4);
+const ct_a = vec(4);
+const ct_b = vec(4);
+const bct$1 = vec(8);
+const cat$1 = vec(8);
+const abt$1 = vec(8);
+const u$1 = vec(4);
+
+const _8$2 = vec(8);
+const _8b$1 = vec(8);
+const _16$2 = vec(16);
+const _12 = vec(12);
+
+let fin$2 = vec(192);
+let fin2$1 = vec(192);
+
+function finadd$1(finlen, alen, a) {
+    finlen = sum(finlen, fin$2, alen, a, fin2$1);
+    const tmp = fin$2; fin$2 = fin2$1; fin2$1 = tmp;
+    return finlen;
+}
+
+function tailinit(xtail, ytail, ax, ay, bx, by, a, b) {
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3, negate;
+    if (xtail === 0) {
+        if (ytail === 0) {
+            a[0] = 0;
+            b[0] = 0;
+            return 1;
+        }
+        negate = -ytail;
+        s1 = negate * ax;
+        c = splitter * negate;
+        ahi = c - (c - negate);
+        alo = negate - ahi;
+        c = splitter * ax;
+        bhi = c - (c - ax);
+        blo = ax - bhi;
+        a[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+        a[1] = s1;
+        s1 = ytail * bx;
+        c = splitter * ytail;
+        ahi = c - (c - ytail);
+        alo = ytail - ahi;
+        c = splitter * bx;
+        bhi = c - (c - bx);
+        blo = bx - bhi;
+        b[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+        b[1] = s1;
+        return 2;
+    }
+    if (ytail === 0) {
+        s1 = xtail * ay;
+        c = splitter * xtail;
+        ahi = c - (c - xtail);
+        alo = xtail - ahi;
+        c = splitter * ay;
+        bhi = c - (c - ay);
+        blo = ay - bhi;
+        a[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+        a[1] = s1;
+        negate = -xtail;
+        s1 = negate * by;
+        c = splitter * negate;
+        ahi = c - (c - negate);
+        alo = negate - ahi;
+        c = splitter * by;
+        bhi = c - (c - by);
+        blo = by - bhi;
+        b[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+        b[1] = s1;
+        return 2;
+    }
+    s1 = xtail * ay;
+    c = splitter * xtail;
+    ahi = c - (c - xtail);
+    alo = xtail - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ytail * ax;
+    c = splitter * ytail;
+    ahi = c - (c - ytail);
+    alo = ytail - ahi;
+    c = splitter * ax;
+    bhi = c - (c - ax);
+    blo = ax - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    a[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    a[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    a[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    a[3] = u3;
+    s1 = ytail * bx;
+    c = splitter * ytail;
+    ahi = c - (c - ytail);
+    alo = ytail - ahi;
+    c = splitter * bx;
+    bhi = c - (c - bx);
+    blo = bx - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = xtail * by;
+    c = splitter * xtail;
+    ahi = c - (c - xtail);
+    alo = xtail - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    b[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    b[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    b[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    b[3] = u3;
+    return 4;
+}
+
+function tailadd(finlen, a, b, k, z) {
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, u3;
+    s1 = a * b;
+    c = splitter * a;
+    ahi = c - (c - a);
+    alo = a - ahi;
+    c = splitter * b;
+    bhi = c - (c - b);
+    blo = b - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    c = splitter * k;
+    bhi = c - (c - k);
+    blo = k - bhi;
+    _i = s0 * k;
+    c = splitter * s0;
+    ahi = c - (c - s0);
+    alo = s0 - ahi;
+    u$1[0] = alo * blo - (_i - ahi * bhi - alo * bhi - ahi * blo);
+    _j = s1 * k;
+    c = splitter * s1;
+    ahi = c - (c - s1);
+    alo = s1 - ahi;
+    _0 = alo * blo - (_j - ahi * bhi - alo * bhi - ahi * blo);
+    _k = _i + _0;
+    bvirt = _k - _i;
+    u$1[1] = _i - (_k - bvirt) + (_0 - bvirt);
+    u3 = _j + _k;
+    u$1[2] = _k - (u3 - _j);
+    u$1[3] = u3;
+    finlen = finadd$1(finlen, 4, u$1);
+    if (z !== 0) {
+        c = splitter * z;
+        bhi = c - (c - z);
+        blo = z - bhi;
+        _i = s0 * z;
+        c = splitter * s0;
+        ahi = c - (c - s0);
+        alo = s0 - ahi;
+        u$1[0] = alo * blo - (_i - ahi * bhi - alo * bhi - ahi * blo);
+        _j = s1 * z;
+        c = splitter * s1;
+        ahi = c - (c - s1);
+        alo = s1 - ahi;
+        _0 = alo * blo - (_j - ahi * bhi - alo * bhi - ahi * blo);
+        _k = _i + _0;
+        bvirt = _k - _i;
+        u$1[1] = _i - (_k - bvirt) + (_0 - bvirt);
+        u3 = _j + _k;
+        u$1[2] = _k - (u3 - _j);
+        u$1[3] = u3;
+        finlen = finadd$1(finlen, 4, u$1);
+    }
+    return finlen;
+}
+
+function orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent) {
+    let finlen;
+    let adxtail, bdxtail, cdxtail;
+    let adytail, bdytail, cdytail;
+    let adztail, bdztail, cdztail;
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+    const adz = az - dz;
+    const bdz = bz - dz;
+    const cdz = cz - dz;
+
+    s1 = bdx * cdy;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cdx * bdy;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc$2[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bc$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bc$2[3] = u3;
+    s1 = cdx * ady;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = adx * cdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ca$1[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ca$1[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ca$1[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ca$1[3] = u3;
+    s1 = adx * bdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bdx * ady;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab$2[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ab$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ab$2[3] = u3;
+
+    finlen = sum(
+        sum(
+            scale(4, bc$2, adz, _8$2), _8$2,
+            scale(4, ca$1, bdz, _8b$1), _8b$1, _16$2), _16$2,
+        scale(4, ab$2, cdz, _8$2), _8$2, fin$2);
+
+    let det = estimate(finlen, fin$2);
+    let errbound = o3derrboundB * permanent;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - adx;
+    adxtail = ax - (adx + bvirt) + (bvirt - dx);
+    bvirt = bx - bdx;
+    bdxtail = bx - (bdx + bvirt) + (bvirt - dx);
+    bvirt = cx - cdx;
+    cdxtail = cx - (cdx + bvirt) + (bvirt - dx);
+    bvirt = ay - ady;
+    adytail = ay - (ady + bvirt) + (bvirt - dy);
+    bvirt = by - bdy;
+    bdytail = by - (bdy + bvirt) + (bvirt - dy);
+    bvirt = cy - cdy;
+    cdytail = cy - (cdy + bvirt) + (bvirt - dy);
+    bvirt = az - adz;
+    adztail = az - (adz + bvirt) + (bvirt - dz);
+    bvirt = bz - bdz;
+    bdztail = bz - (bdz + bvirt) + (bvirt - dz);
+    bvirt = cz - cdz;
+    cdztail = cz - (cdz + bvirt) + (bvirt - dz);
+
+    if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 &&
+        adytail === 0 && bdytail === 0 && cdytail === 0 &&
+        adztail === 0 && bdztail === 0 && cdztail === 0) {
+        return det;
+    }
+
+    errbound = o3derrboundC * permanent + resulterrbound * Math.abs(det);
+    det +=
+        adz * (bdx * cdytail + cdy * bdxtail - (bdy * cdxtail + cdx * bdytail)) + adztail * (bdx * cdy - bdy * cdx) +
+        bdz * (cdx * adytail + ady * cdxtail - (cdy * adxtail + adx * cdytail)) + bdztail * (cdx * ady - cdy * adx) +
+        cdz * (adx * bdytail + bdy * adxtail - (ady * bdxtail + bdx * adytail)) + cdztail * (adx * bdy - ady * bdx);
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    const at_len = tailinit(adxtail, adytail, bdx, bdy, cdx, cdy, at_b, at_c);
+    const bt_len = tailinit(bdxtail, bdytail, cdx, cdy, adx, ady, bt_c, bt_a);
+    const ct_len = tailinit(cdxtail, cdytail, adx, ady, bdx, bdy, ct_a, ct_b);
+
+    const bctlen = sum(bt_len, bt_c, ct_len, ct_b, bct$1);
+    finlen = finadd$1(finlen, scale(bctlen, bct$1, adz, _16$2), _16$2);
+
+    const catlen = sum(ct_len, ct_a, at_len, at_c, cat$1);
+    finlen = finadd$1(finlen, scale(catlen, cat$1, bdz, _16$2), _16$2);
+
+    const abtlen = sum(at_len, at_b, bt_len, bt_a, abt$1);
+    finlen = finadd$1(finlen, scale(abtlen, abt$1, cdz, _16$2), _16$2);
+
+    if (adztail !== 0) {
+        finlen = finadd$1(finlen, scale(4, bc$2, adztail, _12), _12);
+        finlen = finadd$1(finlen, scale(bctlen, bct$1, adztail, _16$2), _16$2);
+    }
+    if (bdztail !== 0) {
+        finlen = finadd$1(finlen, scale(4, ca$1, bdztail, _12), _12);
+        finlen = finadd$1(finlen, scale(catlen, cat$1, bdztail, _16$2), _16$2);
+    }
+    if (cdztail !== 0) {
+        finlen = finadd$1(finlen, scale(4, ab$2, cdztail, _12), _12);
+        finlen = finadd$1(finlen, scale(abtlen, abt$1, cdztail, _16$2), _16$2);
+    }
+
+    if (adxtail !== 0) {
+        if (bdytail !== 0) {
+            finlen = tailadd(finlen, adxtail, bdytail, cdz, cdztail);
+        }
+        if (cdytail !== 0) {
+            finlen = tailadd(finlen, -adxtail, cdytail, bdz, bdztail);
+        }
+    }
+    if (bdxtail !== 0) {
+        if (cdytail !== 0) {
+            finlen = tailadd(finlen, bdxtail, cdytail, adz, adztail);
+        }
+        if (adytail !== 0) {
+            finlen = tailadd(finlen, -bdxtail, adytail, cdz, cdztail);
+        }
+    }
+    if (cdxtail !== 0) {
+        if (adytail !== 0) {
+            finlen = tailadd(finlen, cdxtail, adytail, bdz, bdztail);
+        }
+        if (bdytail !== 0) {
+            finlen = tailadd(finlen, -cdxtail, bdytail, adz, adztail);
+        }
+    }
+
+    return fin$2[finlen - 1];
+}
+
+function orient3d(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+    const adz = az - dz;
+    const bdz = bz - dz;
+    const cdz = cz - dz;
+
+    const bdxcdy = bdx * cdy;
+    const cdxbdy = cdx * bdy;
+
+    const cdxady = cdx * ady;
+    const adxcdy = adx * cdy;
+
+    const adxbdy = adx * bdy;
+    const bdxady = bdx * ady;
+
+    const det =
+        adz * (bdxcdy - cdxbdy) +
+        bdz * (cdxady - adxcdy) +
+        cdz * (adxbdy - bdxady);
+
+    const permanent =
+        (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * Math.abs(adz) +
+        (Math.abs(cdxady) + Math.abs(adxcdy)) * Math.abs(bdz) +
+        (Math.abs(adxbdy) + Math.abs(bdxady)) * Math.abs(cdz);
+
+    const errbound = o3derrboundA * permanent;
+    if (det > errbound || -det > errbound) {
+        return det;
+    }
+
+    return orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent);
+}
+
+function orient3dfast(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+    const adz = az - dz;
+    const bdz = bz - dz;
+    const cdz = cz - dz;
+
+    return adx * (bdy * cdz - bdz * cdy) +
+        bdx * (cdy * adz - cdz * ady) +
+        cdx * (ady * bdz - adz * bdy);
+}
+
+const iccerrboundA = (10 + 96 * epsilon) * epsilon;
+const iccerrboundB = (4 + 48 * epsilon) * epsilon;
+const iccerrboundC = (44 + 576 * epsilon) * epsilon * epsilon;
+
+const bc$1 = vec(4);
+const ca = vec(4);
+const ab$1 = vec(4);
+const aa = vec(4);
+const bb = vec(4);
+const cc = vec(4);
+const u = vec(4);
+const v = vec(4);
+const axtbc = vec(8);
+const aytbc = vec(8);
+const bxtca = vec(8);
+const bytca = vec(8);
+const cxtab = vec(8);
+const cytab = vec(8);
+const abt = vec(8);
+const bct = vec(8);
+const cat = vec(8);
+const abtt = vec(4);
+const bctt = vec(4);
+const catt = vec(4);
+
+const _8$1 = vec(8);
+const _16$1 = vec(16);
+const _16b = vec(16);
+const _16c = vec(16);
+const _32 = vec(32);
+const _32b = vec(32);
+const _48$1 = vec(48);
+const _64 = vec(64);
+
+let fin$1 = vec(1152);
+let fin2 = vec(1152);
+
+function finadd(finlen, a, alen) {
+    finlen = sum(finlen, fin$1, a, alen, fin2);
+    const tmp = fin$1; fin$1 = fin2; fin2 = tmp;
+    return finlen;
+}
+
+function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
+    let finlen;
+    let adxtail, bdxtail, cdxtail, adytail, bdytail, cdytail;
+    let axtbclen, aytbclen, bxtcalen, bytcalen, cxtablen, cytablen;
+    let abtlen, bctlen, catlen;
+    let abttlen, bcttlen, cattlen;
+    let n1, n0;
+
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+
+    s1 = bdx * cdy;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cdx * bdy;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc$1[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc$1[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bc$1[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bc$1[3] = u3;
+    s1 = cdx * ady;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = adx * cdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ca[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ca[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ca[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ca[3] = u3;
+    s1 = adx * bdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bdx * ady;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab$1[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab$1[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ab$1[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ab$1[3] = u3;
+
+    finlen = sum(
+        sum(
+            sum(
+                scale(scale(4, bc$1, adx, _8$1), _8$1, adx, _16$1), _16$1,
+                scale(scale(4, bc$1, ady, _8$1), _8$1, ady, _16b), _16b, _32), _32,
+            sum(
+                scale(scale(4, ca, bdx, _8$1), _8$1, bdx, _16$1), _16$1,
+                scale(scale(4, ca, bdy, _8$1), _8$1, bdy, _16b), _16b, _32b), _32b, _64), _64,
+        sum(
+            scale(scale(4, ab$1, cdx, _8$1), _8$1, cdx, _16$1), _16$1,
+            scale(scale(4, ab$1, cdy, _8$1), _8$1, cdy, _16b), _16b, _32), _32, fin$1);
+
+    let det = estimate(finlen, fin$1);
+    let errbound = iccerrboundB * permanent;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - adx;
+    adxtail = ax - (adx + bvirt) + (bvirt - dx);
+    bvirt = ay - ady;
+    adytail = ay - (ady + bvirt) + (bvirt - dy);
+    bvirt = bx - bdx;
+    bdxtail = bx - (bdx + bvirt) + (bvirt - dx);
+    bvirt = by - bdy;
+    bdytail = by - (bdy + bvirt) + (bvirt - dy);
+    bvirt = cx - cdx;
+    cdxtail = cx - (cdx + bvirt) + (bvirt - dx);
+    bvirt = cy - cdy;
+    cdytail = cy - (cdy + bvirt) + (bvirt - dy);
+    if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 && adytail === 0 && bdytail === 0 && cdytail === 0) {
+        return det;
+    }
+
+    errbound = iccerrboundC * permanent + resulterrbound * Math.abs(det);
+    det += ((adx * adx + ady * ady) * ((bdx * cdytail + cdy * bdxtail) - (bdy * cdxtail + cdx * bdytail)) +
+        2 * (adx * adxtail + ady * adytail) * (bdx * cdy - bdy * cdx)) +
+        ((bdx * bdx + bdy * bdy) * ((cdx * adytail + ady * cdxtail) - (cdy * adxtail + adx * cdytail)) +
+        2 * (bdx * bdxtail + bdy * bdytail) * (cdx * ady - cdy * adx)) +
+        ((cdx * cdx + cdy * cdy) * ((adx * bdytail + bdy * adxtail) - (ady * bdxtail + bdx * adytail)) +
+        2 * (cdx * cdxtail + cdy * cdytail) * (adx * bdy - ady * bdx));
+
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {
+        s1 = adx * adx;
+        c = splitter * adx;
+        ahi = c - (c - adx);
+        alo = adx - ahi;
+        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
+        t1 = ady * ady;
+        c = splitter * ady;
+        ahi = c - (c - ady);
+        alo = ady - ahi;
+        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
+        _i = s0 + t0;
+        bvirt = _i - s0;
+        aa[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        aa[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        aa[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        aa[3] = u3;
+    }
+    if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {
+        s1 = bdx * bdx;
+        c = splitter * bdx;
+        ahi = c - (c - bdx);
+        alo = bdx - ahi;
+        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
+        t1 = bdy * bdy;
+        c = splitter * bdy;
+        ahi = c - (c - bdy);
+        alo = bdy - ahi;
+        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
+        _i = s0 + t0;
+        bvirt = _i - s0;
+        bb[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        bb[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        bb[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        bb[3] = u3;
+    }
+    if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {
+        s1 = cdx * cdx;
+        c = splitter * cdx;
+        ahi = c - (c - cdx);
+        alo = cdx - ahi;
+        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
+        t1 = cdy * cdy;
+        c = splitter * cdy;
+        ahi = c - (c - cdy);
+        alo = cdy - ahi;
+        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
+        _i = s0 + t0;
+        bvirt = _i - s0;
+        cc[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        cc[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        cc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        cc[3] = u3;
+    }
+
+    if (adxtail !== 0) {
+        axtbclen = scale(4, bc$1, adxtail, axtbc);
+        finlen = finadd(finlen, sum_three(
+            scale(axtbclen, axtbc, 2 * adx, _16$1), _16$1,
+            scale(scale(4, cc, adxtail, _8$1), _8$1, bdy, _16b), _16b,
+            scale(scale(4, bb, adxtail, _8$1), _8$1, -cdy, _16c), _16c, _32, _48$1), _48$1);
+    }
+    if (adytail !== 0) {
+        aytbclen = scale(4, bc$1, adytail, aytbc);
+        finlen = finadd(finlen, sum_three(
+            scale(aytbclen, aytbc, 2 * ady, _16$1), _16$1,
+            scale(scale(4, bb, adytail, _8$1), _8$1, cdx, _16b), _16b,
+            scale(scale(4, cc, adytail, _8$1), _8$1, -bdx, _16c), _16c, _32, _48$1), _48$1);
+    }
+    if (bdxtail !== 0) {
+        bxtcalen = scale(4, ca, bdxtail, bxtca);
+        finlen = finadd(finlen, sum_three(
+            scale(bxtcalen, bxtca, 2 * bdx, _16$1), _16$1,
+            scale(scale(4, aa, bdxtail, _8$1), _8$1, cdy, _16b), _16b,
+            scale(scale(4, cc, bdxtail, _8$1), _8$1, -ady, _16c), _16c, _32, _48$1), _48$1);
+    }
+    if (bdytail !== 0) {
+        bytcalen = scale(4, ca, bdytail, bytca);
+        finlen = finadd(finlen, sum_three(
+            scale(bytcalen, bytca, 2 * bdy, _16$1), _16$1,
+            scale(scale(4, cc, bdytail, _8$1), _8$1, adx, _16b), _16b,
+            scale(scale(4, aa, bdytail, _8$1), _8$1, -cdx, _16c), _16c, _32, _48$1), _48$1);
+    }
+    if (cdxtail !== 0) {
+        cxtablen = scale(4, ab$1, cdxtail, cxtab);
+        finlen = finadd(finlen, sum_three(
+            scale(cxtablen, cxtab, 2 * cdx, _16$1), _16$1,
+            scale(scale(4, bb, cdxtail, _8$1), _8$1, ady, _16b), _16b,
+            scale(scale(4, aa, cdxtail, _8$1), _8$1, -bdy, _16c), _16c, _32, _48$1), _48$1);
+    }
+    if (cdytail !== 0) {
+        cytablen = scale(4, ab$1, cdytail, cytab);
+        finlen = finadd(finlen, sum_three(
+            scale(cytablen, cytab, 2 * cdy, _16$1), _16$1,
+            scale(scale(4, aa, cdytail, _8$1), _8$1, bdx, _16b), _16b,
+            scale(scale(4, bb, cdytail, _8$1), _8$1, -adx, _16c), _16c, _32, _48$1), _48$1);
+    }
+
+    if (adxtail !== 0 || adytail !== 0) {
+        if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {
+            s1 = bdxtail * cdy;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * cdy;
+            bhi = c - (c - cdy);
+            blo = cdy - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = bdx * cdytail;
+            c = splitter * bdx;
+            ahi = c - (c - bdx);
+            alo = bdx - ahi;
+            c = splitter * cdytail;
+            bhi = c - (c - cdytail);
+            blo = cdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
+            s1 = cdxtail * -bdy;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * -bdy;
+            bhi = c - (c - -bdy);
+            blo = -bdy - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdx * -bdytail;
+            c = splitter * cdx;
+            ahi = c - (c - cdx);
+            alo = cdx - ahi;
+            c = splitter * -bdytail;
+            bhi = c - (c - -bdytail);
+            blo = -bdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            v[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            v[3] = u3;
+            bctlen = sum(4, u, 4, v, bct);
+            s1 = bdxtail * cdytail;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * cdytail;
+            bhi = c - (c - cdytail);
+            blo = cdytail - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdxtail * bdytail;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * bdytail;
+            bhi = c - (c - bdytail);
+            blo = bdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 - t0;
+            bvirt = s0 - _i;
+            bctt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            bctt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            bctt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            bctt[3] = u3;
+            bcttlen = 4;
+        } else {
+            bct[0] = 0;
+            bctlen = 1;
+            bctt[0] = 0;
+            bcttlen = 1;
+        }
+        if (adxtail !== 0) {
+            const len = scale(bctlen, bct, adxtail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(axtbclen, axtbc, adxtail, _16$1), _16$1,
+                scale(len, _16c, 2 * adx, _32), _32, _48$1), _48$1);
+
+            const len2 = scale(bcttlen, bctt, adxtail, _8$1);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8$1, 2 * adx, _16$1), _16$1,
+                scale(len2, _8$1, adxtail, _16b), _16b,
+                scale(len, _16c, adxtail, _32), _32, _32b, _64), _64);
+
+            if (bdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, cc, adxtail, _8$1), _8$1, bdytail, _16$1), _16$1);
+            }
+            if (cdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, bb, -adxtail, _8$1), _8$1, cdytail, _16$1), _16$1);
+            }
+        }
+        if (adytail !== 0) {
+            const len = scale(bctlen, bct, adytail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(aytbclen, aytbc, adytail, _16$1), _16$1,
+                scale(len, _16c, 2 * ady, _32), _32, _48$1), _48$1);
+
+            const len2 = scale(bcttlen, bctt, adytail, _8$1);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8$1, 2 * ady, _16$1), _16$1,
+                scale(len2, _8$1, adytail, _16b), _16b,
+                scale(len, _16c, adytail, _32), _32, _32b, _64), _64);
+        }
+    }
+    if (bdxtail !== 0 || bdytail !== 0) {
+        if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {
+            s1 = cdxtail * ady;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * ady;
+            bhi = c - (c - ady);
+            blo = ady - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdx * adytail;
+            c = splitter * cdx;
+            ahi = c - (c - cdx);
+            alo = cdx - ahi;
+            c = splitter * adytail;
+            bhi = c - (c - adytail);
+            blo = adytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
+            n1 = -cdy;
+            n0 = -cdytail;
+            s1 = adxtail * n1;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * n1;
+            bhi = c - (c - n1);
+            blo = n1 - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = adx * n0;
+            c = splitter * adx;
+            ahi = c - (c - adx);
+            alo = adx - ahi;
+            c = splitter * n0;
+            bhi = c - (c - n0);
+            blo = n0 - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            v[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            v[3] = u3;
+            catlen = sum(4, u, 4, v, cat);
+            s1 = cdxtail * adytail;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * adytail;
+            bhi = c - (c - adytail);
+            blo = adytail - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = adxtail * cdytail;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * cdytail;
+            bhi = c - (c - cdytail);
+            blo = cdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 - t0;
+            bvirt = s0 - _i;
+            catt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            catt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            catt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            catt[3] = u3;
+            cattlen = 4;
+        } else {
+            cat[0] = 0;
+            catlen = 1;
+            catt[0] = 0;
+            cattlen = 1;
+        }
+        if (bdxtail !== 0) {
+            const len = scale(catlen, cat, bdxtail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(bxtcalen, bxtca, bdxtail, _16$1), _16$1,
+                scale(len, _16c, 2 * bdx, _32), _32, _48$1), _48$1);
+
+            const len2 = scale(cattlen, catt, bdxtail, _8$1);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8$1, 2 * bdx, _16$1), _16$1,
+                scale(len2, _8$1, bdxtail, _16b), _16b,
+                scale(len, _16c, bdxtail, _32), _32, _32b, _64), _64);
+
+            if (cdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, aa, bdxtail, _8$1), _8$1, cdytail, _16$1), _16$1);
+            }
+            if (adytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, cc, -bdxtail, _8$1), _8$1, adytail, _16$1), _16$1);
+            }
+        }
+        if (bdytail !== 0) {
+            const len = scale(catlen, cat, bdytail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(bytcalen, bytca, bdytail, _16$1), _16$1,
+                scale(len, _16c, 2 * bdy, _32), _32, _48$1), _48$1);
+
+            const len2 = scale(cattlen, catt, bdytail, _8$1);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8$1, 2 * bdy, _16$1), _16$1,
+                scale(len2, _8$1, bdytail, _16b), _16b,
+                scale(len, _16c, bdytail, _32), _32,  _32b, _64), _64);
+        }
+    }
+    if (cdxtail !== 0 || cdytail !== 0) {
+        if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {
+            s1 = adxtail * bdy;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * bdy;
+            bhi = c - (c - bdy);
+            blo = bdy - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = adx * bdytail;
+            c = splitter * adx;
+            ahi = c - (c - adx);
+            alo = adx - ahi;
+            c = splitter * bdytail;
+            bhi = c - (c - bdytail);
+            blo = bdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
+            n1 = -ady;
+            n0 = -adytail;
+            s1 = bdxtail * n1;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * n1;
+            bhi = c - (c - n1);
+            blo = n1 - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = bdx * n0;
+            c = splitter * bdx;
+            ahi = c - (c - bdx);
+            alo = bdx - ahi;
+            c = splitter * n0;
+            bhi = c - (c - n0);
+            blo = n0 - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            v[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            v[3] = u3;
+            abtlen = sum(4, u, 4, v, abt);
+            s1 = adxtail * bdytail;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * bdytail;
+            bhi = c - (c - bdytail);
+            blo = bdytail - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = bdxtail * adytail;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * adytail;
+            bhi = c - (c - adytail);
+            blo = adytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 - t0;
+            bvirt = s0 - _i;
+            abtt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            abtt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            abtt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            abtt[3] = u3;
+            abttlen = 4;
+        } else {
+            abt[0] = 0;
+            abtlen = 1;
+            abtt[0] = 0;
+            abttlen = 1;
+        }
+        if (cdxtail !== 0) {
+            const len = scale(abtlen, abt, cdxtail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(cxtablen, cxtab, cdxtail, _16$1), _16$1,
+                scale(len, _16c, 2 * cdx, _32), _32, _48$1), _48$1);
+
+            const len2 = scale(abttlen, abtt, cdxtail, _8$1);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8$1, 2 * cdx, _16$1), _16$1,
+                scale(len2, _8$1, cdxtail, _16b), _16b,
+                scale(len, _16c, cdxtail, _32), _32, _32b, _64), _64);
+
+            if (adytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, bb, cdxtail, _8$1), _8$1, adytail, _16$1), _16$1);
+            }
+            if (bdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, aa, -cdxtail, _8$1), _8$1, bdytail, _16$1), _16$1);
+            }
+        }
+        if (cdytail !== 0) {
+            const len = scale(abtlen, abt, cdytail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(cytablen, cytab, cdytail, _16$1), _16$1,
+                scale(len, _16c, 2 * cdy, _32), _32, _48$1), _48$1);
+
+            const len2 = scale(abttlen, abtt, cdytail, _8$1);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8$1, 2 * cdy, _16$1), _16$1,
+                scale(len2, _8$1, cdytail, _16b), _16b,
+                scale(len, _16c, cdytail, _32), _32, _32b, _64), _64);
+        }
+    }
+
+    return fin$1[finlen - 1];
+}
+
+function incircle(ax, ay, bx, by, cx, cy, dx, dy) {
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+
+    const bdxcdy = bdx * cdy;
+    const cdxbdy = cdx * bdy;
+    const alift = adx * adx + ady * ady;
+
+    const cdxady = cdx * ady;
+    const adxcdy = adx * cdy;
+    const blift = bdx * bdx + bdy * bdy;
+
+    const adxbdy = adx * bdy;
+    const bdxady = bdx * ady;
+    const clift = cdx * cdx + cdy * cdy;
+
+    const det =
+        alift * (bdxcdy - cdxbdy) +
+        blift * (cdxady - adxcdy) +
+        clift * (adxbdy - bdxady);
+
+    const permanent =
+        (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * alift +
+        (Math.abs(cdxady) + Math.abs(adxcdy)) * blift +
+        (Math.abs(adxbdy) + Math.abs(bdxady)) * clift;
+
+    const errbound = iccerrboundA * permanent;
+
+    if (det > errbound || -det > errbound) {
+        return det;
+    }
+    return incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent);
+}
+
+function incirclefast(ax, ay, bx, by, cx, cy, dx, dy) {
+    const adx = ax - dx;
+    const ady = ay - dy;
+    const bdx = bx - dx;
+    const bdy = by - dy;
+    const cdx = cx - dx;
+    const cdy = cy - dy;
+
+    const abdet = adx * bdy - bdx * ady;
+    const bcdet = bdx * cdy - cdx * bdy;
+    const cadet = cdx * ady - adx * cdy;
+    const alift = adx * adx + ady * ady;
+    const blift = bdx * bdx + bdy * bdy;
+    const clift = cdx * cdx + cdy * cdy;
+
+    return alift * bcdet + blift * cadet + clift * abdet;
+}
+
+const isperrboundA = (16 + 224 * epsilon) * epsilon;
+const isperrboundB = (5 + 72 * epsilon) * epsilon;
+const isperrboundC = (71 + 1408 * epsilon) * epsilon * epsilon;
+
+const ab = vec(4);
+const bc = vec(4);
+const cd = vec(4);
+const de = vec(4);
+const ea = vec(4);
+const ac = vec(4);
+const bd = vec(4);
+const ce = vec(4);
+const da = vec(4);
+const eb = vec(4);
+
+const abc = vec(24);
+const bcd = vec(24);
+const cde = vec(24);
+const dea = vec(24);
+const eab = vec(24);
+const abd = vec(24);
+const bce = vec(24);
+const cda = vec(24);
+const deb = vec(24);
+const eac = vec(24);
+
+const adet = vec(1152);
+const bdet = vec(1152);
+const cdet = vec(1152);
+const ddet = vec(1152);
+const edet = vec(1152);
+const abdet = vec(2304);
+const cddet = vec(2304);
+const cdedet = vec(3456);
+const deter = vec(5760);
+
+const _8 = vec(8);
+const _8b = vec(8);
+const _8c = vec(8);
+const _16 = vec(16);
+const _24 = vec(24);
+const _48 = vec(48);
+const _48b = vec(48);
+const _96 = vec(96);
+const _192 = vec(192);
+const _384x = vec(384);
+const _384y = vec(384);
+const _384z = vec(384);
+const _768 = vec(768);
+
+function sum_three_scale(a, b, c, az, bz, cz, out) {
+    return sum_three(
+        scale(4, a, az, _8), _8,
+        scale(4, b, bz, _8b), _8b,
+        scale(4, c, cz, _8c), _8c, _16, out);
+}
+
+function liftexact(alen, a, blen, b, clen, c, dlen, d, x, y, z, out) {
+    const len = sum(
+        sum(alen, a, blen, b, _48), _48,
+        negate(sum(clen, c, dlen, d, _48b), _48b), _48b, _96);
+
+    return sum_three(
+        scale(scale(len, _96, x, _192), _192, x, _384x), _384x,
+        scale(scale(len, _96, y, _192), _192, y, _384y), _384y,
+        scale(scale(len, _96, z, _192), _192, z, _384z), _384z, _768, out);
+}
+
+function insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    s1 = ax * by;
+    c = splitter * ax;
+    ahi = c - (c - ax);
+    alo = ax - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bx * ay;
+    c = splitter * bx;
+    ahi = c - (c - bx);
+    alo = bx - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ab[3] = u3;
+    s1 = bx * cy;
+    c = splitter * bx;
+    ahi = c - (c - bx);
+    alo = bx - ahi;
+    c = splitter * cy;
+    bhi = c - (c - cy);
+    blo = cy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cx * by;
+    c = splitter * cx;
+    ahi = c - (c - cx);
+    alo = cx - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bc[3] = u3;
+    s1 = cx * dy;
+    c = splitter * cx;
+    ahi = c - (c - cx);
+    alo = cx - ahi;
+    c = splitter * dy;
+    bhi = c - (c - dy);
+    blo = dy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = dx * cy;
+    c = splitter * dx;
+    ahi = c - (c - dx);
+    alo = dx - ahi;
+    c = splitter * cy;
+    bhi = c - (c - cy);
+    blo = cy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    cd[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    cd[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    cd[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    cd[3] = u3;
+    s1 = dx * ey;
+    c = splitter * dx;
+    ahi = c - (c - dx);
+    alo = dx - ahi;
+    c = splitter * ey;
+    bhi = c - (c - ey);
+    blo = ey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ex * dy;
+    c = splitter * ex;
+    ahi = c - (c - ex);
+    alo = ex - ahi;
+    c = splitter * dy;
+    bhi = c - (c - dy);
+    blo = dy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    de[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    de[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    de[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    de[3] = u3;
+    s1 = ex * ay;
+    c = splitter * ex;
+    ahi = c - (c - ex);
+    alo = ex - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ax * ey;
+    c = splitter * ax;
+    ahi = c - (c - ax);
+    alo = ax - ahi;
+    c = splitter * ey;
+    bhi = c - (c - ey);
+    blo = ey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ea[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ea[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ea[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ea[3] = u3;
+    s1 = ax * cy;
+    c = splitter * ax;
+    ahi = c - (c - ax);
+    alo = ax - ahi;
+    c = splitter * cy;
+    bhi = c - (c - cy);
+    blo = cy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cx * ay;
+    c = splitter * cx;
+    ahi = c - (c - cx);
+    alo = cx - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ac[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ac[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ac[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ac[3] = u3;
+    s1 = bx * dy;
+    c = splitter * bx;
+    ahi = c - (c - bx);
+    alo = bx - ahi;
+    c = splitter * dy;
+    bhi = c - (c - dy);
+    blo = dy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = dx * by;
+    c = splitter * dx;
+    ahi = c - (c - dx);
+    alo = dx - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bd[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bd[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bd[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bd[3] = u3;
+    s1 = cx * ey;
+    c = splitter * cx;
+    ahi = c - (c - cx);
+    alo = cx - ahi;
+    c = splitter * ey;
+    bhi = c - (c - ey);
+    blo = ey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ex * cy;
+    c = splitter * ex;
+    ahi = c - (c - ex);
+    alo = ex - ahi;
+    c = splitter * cy;
+    bhi = c - (c - cy);
+    blo = cy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ce[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ce[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ce[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ce[3] = u3;
+    s1 = dx * ay;
+    c = splitter * dx;
+    ahi = c - (c - dx);
+    alo = dx - ahi;
+    c = splitter * ay;
+    bhi = c - (c - ay);
+    blo = ay - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = ax * dy;
+    c = splitter * ax;
+    ahi = c - (c - ax);
+    alo = ax - ahi;
+    c = splitter * dy;
+    bhi = c - (c - dy);
+    blo = dy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    da[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    da[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    da[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    da[3] = u3;
+    s1 = ex * by;
+    c = splitter * ex;
+    ahi = c - (c - ex);
+    alo = ex - ahi;
+    c = splitter * by;
+    bhi = c - (c - by);
+    blo = by - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bx * ey;
+    c = splitter * bx;
+    ahi = c - (c - bx);
+    alo = bx - ahi;
+    c = splitter * ey;
+    bhi = c - (c - ey);
+    blo = ey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    eb[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    eb[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    eb[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    eb[3] = u3;
+
+    const abclen = sum_three_scale(ab, bc, ac, cz, az, -bz, abc);
+    const bcdlen = sum_three_scale(bc, cd, bd, dz, bz, -cz, bcd);
+    const cdelen = sum_three_scale(cd, de, ce, ez, cz, -dz, cde);
+    const dealen = sum_three_scale(de, ea, da, az, dz, -ez, dea);
+    const eablen = sum_three_scale(ea, ab, eb, bz, ez, -az, eab);
+    const abdlen = sum_three_scale(ab, bd, da, dz, az, bz, abd);
+    const bcelen = sum_three_scale(bc, ce, eb, ez, bz, cz, bce);
+    const cdalen = sum_three_scale(cd, da, ac, az, cz, dz, cda);
+    const deblen = sum_three_scale(de, eb, bd, bz, dz, ez, deb);
+    const eaclen = sum_three_scale(ea, ac, ce, cz, ez, az, eac);
+
+    const deterlen = sum_three(
+        liftexact(cdelen, cde, bcelen, bce, deblen, deb, bcdlen, bcd, ax, ay, az, adet), adet,
+        liftexact(dealen, dea, cdalen, cda, eaclen, eac, cdelen, cde, bx, by, bz, bdet), bdet,
+        sum_three(
+            liftexact(eablen, eab, deblen, deb, abdlen, abd, dealen, dea, cx, cy, cz, cdet), cdet,
+            liftexact(abclen, abc, eaclen, eac, bcelen, bce, eablen, eab, dx, dy, dz, ddet), ddet,
+            liftexact(bcdlen, bcd, abdlen, abd, cdalen, cda, abclen, abc, ex, ey, ez, edet), edet, cddet, cdedet), cdedet, abdet, deter);
+
+    return deter[deterlen - 1];
+}
+
+const xdet = vec(96);
+const ydet = vec(96);
+const zdet = vec(96);
+const fin = vec(1152);
+
+function liftadapt(a, b, c, az, bz, cz, x, y, z, out) {
+    const len = sum_three_scale(a, b, c, az, bz, cz, _24);
+    return sum_three(
+        scale(scale(len, _24, x, _48), _48, x, xdet), xdet,
+        scale(scale(len, _24, y, _48), _48, y, ydet), ydet,
+        scale(scale(len, _24, z, _48), _48, z, zdet), zdet, _192, out);
+}
+
+function insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez, permanent) {
+    let ab3, bc3, cd3, da3, ac3, bd3;
+
+    let aextail, bextail, cextail, dextail;
+    let aeytail, beytail, ceytail, deytail;
+    let aeztail, beztail, ceztail, deztail;
+
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0;
+
+    const aex = ax - ex;
+    const bex = bx - ex;
+    const cex = cx - ex;
+    const dex = dx - ex;
+    const aey = ay - ey;
+    const bey = by - ey;
+    const cey = cy - ey;
+    const dey = dy - ey;
+    const aez = az - ez;
+    const bez = bz - ez;
+    const cez = cz - ez;
+    const dez = dz - ez;
+
+    s1 = aex * bey;
+    c = splitter * aex;
+    ahi = c - (c - aex);
+    alo = aex - ahi;
+    c = splitter * bey;
+    bhi = c - (c - bey);
+    blo = bey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bex * aey;
+    c = splitter * bex;
+    ahi = c - (c - bex);
+    alo = bex - ahi;
+    c = splitter * aey;
+    bhi = c - (c - aey);
+    blo = aey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    ab3 = _j + _i;
+    bvirt = ab3 - _j;
+    ab[2] = _j - (ab3 - bvirt) + (_i - bvirt);
+    ab[3] = ab3;
+    s1 = bex * cey;
+    c = splitter * bex;
+    ahi = c - (c - bex);
+    alo = bex - ahi;
+    c = splitter * cey;
+    bhi = c - (c - cey);
+    blo = cey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cex * bey;
+    c = splitter * cex;
+    ahi = c - (c - cex);
+    alo = cex - ahi;
+    c = splitter * bey;
+    bhi = c - (c - bey);
+    blo = bey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    bc3 = _j + _i;
+    bvirt = bc3 - _j;
+    bc[2] = _j - (bc3 - bvirt) + (_i - bvirt);
+    bc[3] = bc3;
+    s1 = cex * dey;
+    c = splitter * cex;
+    ahi = c - (c - cex);
+    alo = cex - ahi;
+    c = splitter * dey;
+    bhi = c - (c - dey);
+    blo = dey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = dex * cey;
+    c = splitter * dex;
+    ahi = c - (c - dex);
+    alo = dex - ahi;
+    c = splitter * cey;
+    bhi = c - (c - cey);
+    blo = cey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    cd[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    cd[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    cd3 = _j + _i;
+    bvirt = cd3 - _j;
+    cd[2] = _j - (cd3 - bvirt) + (_i - bvirt);
+    cd[3] = cd3;
+    s1 = dex * aey;
+    c = splitter * dex;
+    ahi = c - (c - dex);
+    alo = dex - ahi;
+    c = splitter * aey;
+    bhi = c - (c - aey);
+    blo = aey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = aex * dey;
+    c = splitter * aex;
+    ahi = c - (c - aex);
+    alo = aex - ahi;
+    c = splitter * dey;
+    bhi = c - (c - dey);
+    blo = dey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    da[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    da[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    da3 = _j + _i;
+    bvirt = da3 - _j;
+    da[2] = _j - (da3 - bvirt) + (_i - bvirt);
+    da[3] = da3;
+    s1 = aex * cey;
+    c = splitter * aex;
+    ahi = c - (c - aex);
+    alo = aex - ahi;
+    c = splitter * cey;
+    bhi = c - (c - cey);
+    blo = cey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cex * aey;
+    c = splitter * cex;
+    ahi = c - (c - cex);
+    alo = cex - ahi;
+    c = splitter * aey;
+    bhi = c - (c - aey);
+    blo = aey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ac[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ac[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    ac3 = _j + _i;
+    bvirt = ac3 - _j;
+    ac[2] = _j - (ac3 - bvirt) + (_i - bvirt);
+    ac[3] = ac3;
+    s1 = bex * dey;
+    c = splitter * bex;
+    ahi = c - (c - bex);
+    alo = bex - ahi;
+    c = splitter * dey;
+    bhi = c - (c - dey);
+    blo = dey - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = dex * bey;
+    c = splitter * dex;
+    ahi = c - (c - dex);
+    alo = dex - ahi;
+    c = splitter * bey;
+    bhi = c - (c - bey);
+    blo = bey - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bd[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bd[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    bd3 = _j + _i;
+    bvirt = bd3 - _j;
+    bd[2] = _j - (bd3 - bvirt) + (_i - bvirt);
+    bd[3] = bd3;
+
+    const finlen = sum(
+        sum(
+            negate(liftadapt(bc, cd, bd, dez, bez, -cez, aex, aey, aez, adet), adet), adet,
+            liftadapt(cd, da, ac, aez, cez, dez, bex, bey, bez, bdet), bdet, abdet), abdet,
+        sum(
+            negate(liftadapt(da, ab, bd, bez, dez, aez, cex, cey, cez, cdet), cdet), cdet,
+            liftadapt(ab, bc, ac, cez, aez, -bez, dex, dey, dez, ddet), ddet, cddet), cddet, fin);
+
+    let det = estimate(finlen, fin);
+    let errbound = isperrboundB * permanent;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - aex;
+    aextail = ax - (aex + bvirt) + (bvirt - ex);
+    bvirt = ay - aey;
+    aeytail = ay - (aey + bvirt) + (bvirt - ey);
+    bvirt = az - aez;
+    aeztail = az - (aez + bvirt) + (bvirt - ez);
+    bvirt = bx - bex;
+    bextail = bx - (bex + bvirt) + (bvirt - ex);
+    bvirt = by - bey;
+    beytail = by - (bey + bvirt) + (bvirt - ey);
+    bvirt = bz - bez;
+    beztail = bz - (bez + bvirt) + (bvirt - ez);
+    bvirt = cx - cex;
+    cextail = cx - (cex + bvirt) + (bvirt - ex);
+    bvirt = cy - cey;
+    ceytail = cy - (cey + bvirt) + (bvirt - ey);
+    bvirt = cz - cez;
+    ceztail = cz - (cez + bvirt) + (bvirt - ez);
+    bvirt = dx - dex;
+    dextail = dx - (dex + bvirt) + (bvirt - ex);
+    bvirt = dy - dey;
+    deytail = dy - (dey + bvirt) + (bvirt - ey);
+    bvirt = dz - dez;
+    deztail = dz - (dez + bvirt) + (bvirt - ez);
+    if (aextail === 0 && aeytail === 0 && aeztail === 0 &&
+        bextail === 0 && beytail === 0 && beztail === 0 &&
+        cextail === 0 && ceytail === 0 && ceztail === 0 &&
+        dextail === 0 && deytail === 0 && deztail === 0) {
+        return det;
+    }
+
+    errbound = isperrboundC * permanent + resulterrbound * Math.abs(det);
+
+    const abeps = (aex * beytail + bey * aextail) - (aey * bextail + bex * aeytail);
+    const bceps = (bex * ceytail + cey * bextail) - (bey * cextail + cex * beytail);
+    const cdeps = (cex * deytail + dey * cextail) - (cey * dextail + dex * ceytail);
+    const daeps = (dex * aeytail + aey * dextail) - (dey * aextail + aex * deytail);
+    const aceps = (aex * ceytail + cey * aextail) - (aey * cextail + cex * aeytail);
+    const bdeps = (bex * deytail + dey * bextail) - (bey * dextail + dex * beytail);
+    det +=
+        (((bex * bex + bey * bey + bez * bez) * ((cez * daeps + dez * aceps + aez * cdeps) +
+        (ceztail * da3 + deztail * ac3 + aeztail * cd3)) + (dex * dex + dey * dey + dez * dez) *
+        ((aez * bceps - bez * aceps + cez * abeps) + (aeztail * bc3 - beztail * ac3 + ceztail * ab3))) -
+        ((aex * aex + aey * aey + aez * aez) * ((bez * cdeps - cez * bdeps + dez * bceps) +
+        (beztail * cd3 - ceztail * bd3 + deztail * bc3)) + (cex * cex + cey * cey + cez * cez) *
+        ((dez * abeps + aez * bdeps + bez * daeps) + (deztail * ab3 + aeztail * bd3 + beztail * da3)))) +
+        2 * (((bex * bextail + bey * beytail + bez * beztail) * (cez * da3 + dez * ac3 + aez * cd3) +
+        (dex * dextail + dey * deytail + dez * deztail) * (aez * bc3 - bez * ac3 + cez * ab3)) -
+        ((aex * aextail + aey * aeytail + aez * aeztail) * (bez * cd3 - cez * bd3 + dez * bc3) +
+        (cex * cextail + cey * ceytail + cez * ceztail) * (dez * ab3 + aez * bd3 + bez * da3)));
+
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    return insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez);
+}
+
+function insphere(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {
+    const aex = ax - ex;
+    const bex = bx - ex;
+    const cex = cx - ex;
+    const dex = dx - ex;
+    const aey = ay - ey;
+    const bey = by - ey;
+    const cey = cy - ey;
+    const dey = dy - ey;
+    const aez = az - ez;
+    const bez = bz - ez;
+    const cez = cz - ez;
+    const dez = dz - ez;
+
+    const aexbey = aex * bey;
+    const bexaey = bex * aey;
+    const ab = aexbey - bexaey;
+    const bexcey = bex * cey;
+    const cexbey = cex * bey;
+    const bc = bexcey - cexbey;
+    const cexdey = cex * dey;
+    const dexcey = dex * cey;
+    const cd = cexdey - dexcey;
+    const dexaey = dex * aey;
+    const aexdey = aex * dey;
+    const da = dexaey - aexdey;
+    const aexcey = aex * cey;
+    const cexaey = cex * aey;
+    const ac = aexcey - cexaey;
+    const bexdey = bex * dey;
+    const dexbey = dex * bey;
+    const bd = bexdey - dexbey;
+
+    const alift = aex * aex + aey * aey + aez * aez;
+    const blift = bex * bex + bey * bey + bez * bez;
+    const clift = cex * cex + cey * cey + cez * cez;
+    const dlift = dex * dex + dey * dey + dez * dez;
+
+    const det =
+        (clift * (dez * ab + aez * bd + bez * da) - dlift * (aez * bc - bez * ac + cez * ab)) +
+        (alift * (bez * cd - cez * bd + dez * bc) - blift * (cez * da + dez * ac + aez * cd));
+
+    const aezplus = Math.abs(aez);
+    const bezplus = Math.abs(bez);
+    const cezplus = Math.abs(cez);
+    const dezplus = Math.abs(dez);
+    const aexbeyplus = Math.abs(aexbey) + Math.abs(bexaey);
+    const bexceyplus = Math.abs(bexcey) + Math.abs(cexbey);
+    const cexdeyplus = Math.abs(cexdey) + Math.abs(dexcey);
+    const dexaeyplus = Math.abs(dexaey) + Math.abs(aexdey);
+    const aexceyplus = Math.abs(aexcey) + Math.abs(cexaey);
+    const bexdeyplus = Math.abs(bexdey) + Math.abs(dexbey);
+    const permanent =
+        (cexdeyplus * bezplus + bexdeyplus * cezplus + bexceyplus * dezplus) * alift +
+        (dexaeyplus * cezplus + aexceyplus * dezplus + cexdeyplus * aezplus) * blift +
+        (aexbeyplus * dezplus + bexdeyplus * aezplus + dexaeyplus * bezplus) * clift +
+        (bexceyplus * aezplus + aexceyplus * bezplus + aexbeyplus * cezplus) * dlift;
+
+    const errbound = isperrboundA * permanent;
+    if (det > errbound || -det > errbound) {
+        return det;
+    }
+    return -insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez, permanent);
+}
+
+function inspherefast(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {
+    const aex = ax - ex;
+    const bex = bx - ex;
+    const cex = cx - ex;
+    const dex = dx - ex;
+    const aey = ay - ey;
+    const bey = by - ey;
+    const cey = cy - ey;
+    const dey = dy - ey;
+    const aez = az - ez;
+    const bez = bz - ez;
+    const cez = cz - ez;
+    const dez = dz - ez;
+
+    const ab = aex * bey - bex * aey;
+    const bc = bex * cey - cex * bey;
+    const cd = cex * dey - dex * cey;
+    const da = dex * aey - aex * dey;
+    const ac = aex * cey - cex * aey;
+    const bd = bex * dey - dex * bey;
+
+    const abc = aez * bc - bez * ac + cez * ab;
+    const bcd = bez * cd - cez * bd + dez * bc;
+    const cda = cez * da + dez * ac + aez * cd;
+    const dab = dez * ab + aez * bd + bez * da;
+
+    const alift = aex * aex + aey * aey + aez * aez;
+    const blift = bex * bex + bey * bey + bez * bez;
+    const clift = cex * cex + cey * cey + cez * cez;
+    const dlift = dex * dex + dey * dey + dez * dez;
+
+    return (clift * dab - dlift * abc) + (alift * bcd - blift * cda);
+}
+
+exports.incircle = incircle;
+exports.incirclefast = incirclefast;
+exports.insphere = insphere;
+exports.inspherefast = inspherefast;
+exports.orient2d = orient2d;
+exports.orient2dfast = orient2dfast;
+exports.orient3d = orient3d;
+exports.orient3dfast = orient3dfast;
+
+}));
diff --git a/tools/ui/node_modules/robust-predicates/umd/predicates.min.js b/tools/ui/node_modules/robust-predicates/umd/predicates.min.js
new file mode 100644
index 0000000000000000000000000000000000000000..b92f18a7546e245a9913e85cd89a9d4bd9a5127b
--- /dev/null
+++ b/tools/ui/node_modules/robust-predicates/umd/predicates.min.js
@@ -0,0 +1 @@
+!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((t="undefined"!=typeof globalThis?globalThis:t||self).predicates={})}(this,function(t){"use strict";const n=11102230246251565e-32,e=134217729,r=(3+8*n)*n;function s(t,n,e,r,s){let o,a,c,f,i=n[0],u=r[0],h=0,b=0;u>i==u>-i?(o=i,i=n[++h]):(o=u,u=r[++b]);let M=0;if(hi==u>-i?(a=i+o,c=o-(a-i),i=n[++h]):(a=u+o,c=o-(a-u),u=r[++b]),o=a,0!==c&&(s[M++]=c);hi==u>-i?(a=o+i,f=a-o,c=o-(a-f)+(i-f),i=n[++h]):(a=o+u,f=a-o,c=o-(a-f)+(u-f),u=r[++b]),o=a,0!==c&&(s[M++]=c);for(;h=bt||-ht>=bt)return ht;if(N=t-_,v=t-(_+N)+(N-x),N=n-rt,D=n-(rt+N)+(N-g),N=a-ct,I=a-(ct+N)+(N-m),N=i-tt,z=i-(tt+N)+(N-x),N=u-st,E=u-(st+N)+(N-g),N=h-ft,J=h-(ft+N)+(N-m),N=b-nt,B=b-(nt+N)+(N-x),N=M-ot,G=M-(ot+N)+(N-g),N=l-it,K=l-(it+N)+(N-m),N=d-et,C=d-(et+N)+(N-x),N=p-at,H=p-(at+N)+(N-g),N=y-ut,L=y-(ut+N)+(N-m),0===v&&0===D&&0===I&&0===z&&0===E&&0===J&&0===B&&0===G&&0===K&&0===C&&0===H&&0===L)return ht;bt=8751425667295619e-46*T+r*Math.abs(ht);const Mt=_*E+st*v-(rt*z+tt*D),Qt=tt*G+ot*z-(st*B+nt*E),Rt=nt*H+at*B-(ot*C+et*G),St=et*D+rt*C-(at*v+_*H),Ut=_*G+ot*v-(rt*B+nt*D),Vt=tt*H+at*z-(st*C+et*E);return ht+=(tt*tt+st*st+ft*ft)*(it*St+ut*Ut+ct*Rt+(K*F+L*k+I*A))+(et*et+at*at+ut*ut)*(ct*Qt-ft*Ut+it*Mt+(I*w-J*k+K*j))-((_*_+rt*rt+ct*ct)*(ft*Rt-it*Vt+ut*Qt+(J*A-K*q+L*w))+(nt*nt+ot*ot+it*it)*(ut*Mt+ct*Vt+ft*St+(L*j+I*q+J*F)))+2*((tt*z+st*E+ft*J)*(it*F+ut*k+ct*A)+(et*C+at*H+ut*L)*(ct*w-ft*k+it*j)-((_*v+rt*D+ct*I)*(ft*A-it*q+ut*w)+(nt*B+ot*G+it*K)*(ut*j+ct*q+ft*F))),ht>=bt||-ht>=bt?ht:function(t,n,r,s,a,c,f,i,u,h,b,M,l,d,p){let y,x,g,m,T,j,w,A,F,k,q,v,z,B;k=t*a,x=e*t,g=x-(x-t),m=t-g,x=e*a,T=x-(x-a),j=a-T,q=m*j-(k-g*T-m*T-g*j),v=s*n,x=e*s,g=x-(x-s),m=s-g,x=e*n,T=x-(x-n),j=n-T,z=m*j-(v-g*T-m*T-g*j),w=q-z,y=q-w,lt[0]=q-(w+y)+(y-z),A=k+w,y=A-k,F=k-(A-y)+(w-y),w=F-v,y=F-w,lt[1]=F-(w+y)+(y-v),B=A+w,y=B-A,lt[2]=A-(B-y)+(w-y),lt[3]=B,k=s*i,x=e*s,g=x-(x-s),m=s-g,x=e*i,T=x-(x-i),j=i-T,q=m*j-(k-g*T-m*T-g*j),v=f*a,x=e*f,g=x-(x-f),m=f-g,x=e*a,T=x-(x-a),j=a-T,z=m*j-(v-g*T-m*T-g*j),w=q-z,y=q-w,dt[0]=q-(w+y)+(y-z),A=k+w,y=A-k,F=k-(A-y)+(w-y),w=F-v,y=F-w,dt[1]=F-(w+y)+(y-v),B=A+w,y=B-A,dt[2]=A-(B-y)+(w-y),dt[3]=B,k=f*b,x=e*f,g=x-(x-f),m=f-g,x=e*b,T=x-(x-b),j=b-T,q=m*j-(k-g*T-m*T-g*j),v=h*i,x=e*h,g=x-(x-h),m=h-g,x=e*i,T=x-(x-i),j=i-T,z=m*j-(v-g*T-m*T-g*j),w=q-z,y=q-w,pt[0]=q-(w+y)+(y-z),A=k+w,y=A-k,F=k-(A-y)+(w-y),w=F-v,y=F-w,pt[1]=F-(w+y)+(y-v),B=A+w,y=B-A,pt[2]=A-(B-y)+(w-y),pt[3]=B,k=h*d,x=e*h,g=x-(x-h),m=h-g,x=e*d,T=x-(x-d),j=d-T,q=m*j-(k-g*T-m*T-g*j),v=l*b,x=e*l,g=x-(x-l),m=l-g,x=e*b,T=x-(x-b),j=b-T,z=m*j-(v-g*T-m*T-g*j),w=q-z,y=q-w,yt[0]=q-(w+y)+(y-z),A=k+w,y=A-k,F=k-(A-y)+(w-y),w=F-v,y=F-w,yt[1]=F-(w+y)+(y-v),B=A+w,y=B-A,yt[2]=A-(B-y)+(w-y),yt[3]=B,k=l*n,x=e*l,g=x-(x-l),m=l-g,x=e*n,T=x-(x-n),j=n-T,q=m*j-(k-g*T-m*T-g*j),v=t*d,x=e*t,g=x-(x-t),m=t-g,x=e*d,T=x-(x-d),j=d-T,z=m*j-(v-g*T-m*T-g*j),w=q-z,y=q-w,xt[0]=q-(w+y)+(y-z),A=k+w,y=A-k,F=k-(A-y)+(w-y),w=F-v,y=F-w,xt[1]=F-(w+y)+(y-v),B=A+w,y=B-A,xt[2]=A-(B-y)+(w-y),xt[3]=B,k=t*i,x=e*t,g=x-(x-t),m=t-g,x=e*i,T=x-(x-i),j=i-T,q=m*j-(k-g*T-m*T-g*j),v=f*n,x=e*f,g=x-(x-f),m=f-g,x=e*n,T=x-(x-n),j=n-T,z=m*j-(v-g*T-m*T-g*j),w=q-z,y=q-w,gt[0]=q-(w+y)+(y-z),A=k+w,y=A-k,F=k-(A-y)+(w-y),w=F-v,y=F-w,gt[1]=F-(w+y)+(y-v),B=A+w,y=B-A,gt[2]=A-(B-y)+(w-y),gt[3]=B,k=s*b,x=e*s,g=x-(x-s),m=s-g,x=e*b,T=x-(x-b),j=b-T,q=m*j-(k-g*T-m*T-g*j),v=h*a,x=e*h,g=x-(x-h),m=h-g,x=e*a,T=x-(x-a),j=a-T,z=m*j-(v-g*T-m*T-g*j),w=q-z,y=q-w,mt[0]=q-(w+y)+(y-z),A=k+w,y=A-k,F=k-(A-y)+(w-y),w=F-v,y=F-w,mt[1]=F-(w+y)+(y-v),B=A+w,y=B-A,mt[2]=A-(B-y)+(w-y),mt[3]=B,k=f*d,x=e*f,g=x-(x-f),m=f-g,x=e*d,T=x-(x-d),j=d-T,q=m*j-(k-g*T-m*T-g*j),v=l*i,x=e*l,g=x-(x-l),m=l-g,x=e*i,T=x-(x-i),j=i-T,z=m*j-(v-g*T-m*T-g*j),w=q-z,y=q-w,Tt[0]=q-(w+y)+(y-z),A=k+w,y=A-k,F=k-(A-y)+(w-y),w=F-v,y=F-w,Tt[1]=F-(w+y)+(y-v),B=A+w,y=B-A,Tt[2]=A-(B-y)+(w-y),Tt[3]=B,k=h*n,x=e*h,g=x-(x-h),m=h-g,x=e*n,T=x-(x-n),j=n-T,q=m*j-(k-g*T-m*T-g*j),v=t*b,x=e*t,g=x-(x-t),m=t-g,x=e*b,T=x-(x-b),j=b-T,z=m*j-(v-g*T-m*T-g*j),w=q-z,y=q-w,jt[0]=q-(w+y)+(y-z),A=k+w,y=A-k,F=k-(A-y)+(w-y),w=F-v,y=F-w,jt[1]=F-(w+y)+(y-v),B=A+w,y=B-A,jt[2]=A-(B-y)+(w-y),jt[3]=B,k=l*a,x=e*l,g=x-(x-l),m=l-g,x=e*a,T=x-(x-a),j=a-T,q=m*j-(k-g*T-m*T-g*j),v=s*d,x=e*s,g=x-(x-s),m=s-g,x=e*d,T=x-(x-d),j=d-T,z=m*j-(v-g*T-m*T-g*j),w=q-z,y=q-w,wt[0]=q-(w+y)+(y-z),A=k+w,y=A-k,F=k-(A-y)+(w-y),w=F-v,y=F-w,wt[1]=F-(w+y)+(y-v),B=A+w,y=B-A,wt[2]=A-(B-y)+(w-y),wt[3]=B;const C=en(lt,dt,gt,u,r,-c,At),D=en(dt,pt,mt,M,c,-u,Ft),E=en(pt,yt,Tt,p,u,-M,kt),G=en(yt,xt,jt,r,M,-p,qt),H=en(xt,lt,wt,c,p,-r,vt),I=en(lt,mt,jt,M,r,c,zt),J=en(dt,Tt,wt,p,c,u,Bt),K=en(pt,jt,gt,r,u,M,Ct),L=en(yt,wt,mt,c,M,p,Dt),N=en(xt,gt,Tt,u,p,r,Et),O=o(rn(E,kt,J,Bt,L,Dt,D,Ft,t,n,r,Gt),Gt,rn(G,qt,K,Ct,N,Et,E,kt,s,a,c,Ht),Ht,o(rn(H,vt,L,Dt,I,zt,G,qt,f,i,u,It),It,rn(C,At,N,Et,J,Bt,H,vt,h,b,M,Jt),Jt,rn(D,Ft,I,zt,K,Ct,C,At,l,d,p,Kt),Kt,Nt,Ot),Ot,Lt,Pt);return Pt[O-1]}(t,n,a,i,u,h,b,M,l,d,p,y,x,g,m)}t.incircle=function(t,n,c,i,u,h,b,M){const l=t-b,d=c-b,p=u-b,y=n-M,x=i-M,g=h-M,m=d*g,T=p*x,j=l*l+y*y,w=p*y,A=l*g,F=d*d+x*x,k=l*x,q=d*y,v=p*p+g*g,z=j*(m-T)+F*(w-A)+v*(k-q),B=(Math.abs(m)+Math.abs(T))*j+(Math.abs(w)+Math.abs(A))*F+(Math.abs(k)+Math.abs(q))*v,C=11102230246251577e-31*B;return z>C||-z>C?z:function(t,n,c,i,u,h,b,M,l){let d,p,y,x,g,m,T,j,w,A,F,k,q,v,z,B,C,D,E,G,H,I,bt,lt,dt,pt,yt,xt,gt,mt,Tt,jt,wt,At,Ft;const kt=t-b,qt=c-b,vt=u-b,zt=n-M,Bt=i-M,Ct=h-M;Tt=qt*Ct,bt=e*qt,lt=bt-(bt-qt),dt=qt-lt,bt=e*Ct,pt=bt-(bt-Ct),yt=Ct-pt,jt=dt*yt-(Tt-lt*pt-dt*pt-lt*yt),wt=vt*Bt,bt=e*vt,lt=bt-(bt-vt),dt=vt-lt,bt=e*Bt,pt=bt-(bt-Bt),yt=Bt-pt,At=dt*yt-(wt-lt*pt-dt*pt-lt*yt),xt=jt-At,I=jt-xt,J[0]=jt-(xt+I)+(I-At),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt-wt,I=mt-xt,J[1]=mt-(xt+I)+(I-wt),Ft=gt+xt,I=Ft-gt,J[2]=gt-(Ft-I)+(xt-I),J[3]=Ft,Tt=vt*zt,bt=e*vt,lt=bt-(bt-vt),dt=vt-lt,bt=e*zt,pt=bt-(bt-zt),yt=zt-pt,jt=dt*yt-(Tt-lt*pt-dt*pt-lt*yt),wt=kt*Ct,bt=e*kt,lt=bt-(bt-kt),dt=kt-lt,bt=e*Ct,pt=bt-(bt-Ct),yt=Ct-pt,At=dt*yt-(wt-lt*pt-dt*pt-lt*yt),xt=jt-At,I=jt-xt,K[0]=jt-(xt+I)+(I-At),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt-wt,I=mt-xt,K[1]=mt-(xt+I)+(I-wt),Ft=gt+xt,I=Ft-gt,K[2]=gt-(Ft-I)+(xt-I),K[3]=Ft,Tt=kt*Bt,bt=e*kt,lt=bt-(bt-kt),dt=kt-lt,bt=e*Bt,pt=bt-(bt-Bt),yt=Bt-pt,jt=dt*yt-(Tt-lt*pt-dt*pt-lt*yt),wt=qt*zt,bt=e*qt,lt=bt-(bt-qt),dt=qt-lt,bt=e*zt,pt=bt-(bt-zt),yt=zt-pt,At=dt*yt-(wt-lt*pt-dt*pt-lt*yt),xt=jt-At,I=jt-xt,L[0]=jt-(xt+I)+(I-At),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt-wt,I=mt-xt,L[1]=mt-(xt+I)+(I-wt),Ft=gt+xt,I=Ft-gt,L[2]=gt-(Ft-I)+(xt-I),L[3]=Ft,d=s(s(s(a(a(4,J,kt,rt),rt,kt,st),st,a(a(4,J,zt,rt),rt,zt,ot),ot,ct),ct,s(a(a(4,K,qt,rt),rt,qt,st),st,a(a(4,K,Bt,rt),rt,Bt,ot),ot,ft),ft,ut),ut,s(a(a(4,L,vt,rt),rt,vt,st),st,a(a(4,L,Ct,rt),rt,Ct,ot),ot,ct),ct,ht);let Dt=f(d,ht),Et=4440892098500632e-31*l;if(Dt>=Et||-Dt>=Et)return Dt;if(I=t-kt,p=t-(kt+I)+(I-b),I=n-zt,g=n-(zt+I)+(I-M),I=c-qt,y=c-(qt+I)+(I-b),I=i-Bt,m=i-(Bt+I)+(I-M),I=u-vt,x=u-(vt+I)+(I-b),I=h-Ct,T=h-(Ct+I)+(I-M),0===p&&0===y&&0===x&&0===g&&0===m&&0===T)return Dt;if(Et=5423418723394464e-46*l+r*Math.abs(Dt),Dt+=(kt*kt+zt*zt)*(qt*T+Ct*y-(Bt*x+vt*m))+2*(kt*p+zt*g)*(qt*Ct-Bt*vt)+((qt*qt+Bt*Bt)*(vt*g+zt*x-(Ct*p+kt*T))+2*(qt*y+Bt*m)*(vt*zt-Ct*kt))+((vt*vt+Ct*Ct)*(kt*m+Bt*p-(zt*y+qt*g))+2*(vt*x+Ct*T)*(kt*Bt-zt*qt)),Dt>=Et||-Dt>=Et)return Dt;if(0===y&&0===m&&0===x&&0===T||(Tt=kt*kt,bt=e*kt,lt=bt-(bt-kt),dt=kt-lt,jt=dt*dt-(Tt-lt*lt-(lt+lt)*dt),wt=zt*zt,bt=e*zt,lt=bt-(bt-zt),dt=zt-lt,At=dt*dt-(wt-lt*lt-(lt+lt)*dt),xt=jt+At,I=xt-jt,N[0]=jt-(xt-I)+(At-I),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt+wt,I=xt-mt,N[1]=mt-(xt-I)+(wt-I),Ft=gt+xt,I=Ft-gt,N[2]=gt-(Ft-I)+(xt-I),N[3]=Ft),0===x&&0===T&&0===p&&0===g||(Tt=qt*qt,bt=e*qt,lt=bt-(bt-qt),dt=qt-lt,jt=dt*dt-(Tt-lt*lt-(lt+lt)*dt),wt=Bt*Bt,bt=e*Bt,lt=bt-(bt-Bt),dt=Bt-lt,At=dt*dt-(wt-lt*lt-(lt+lt)*dt),xt=jt+At,I=xt-jt,O[0]=jt-(xt-I)+(At-I),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt+wt,I=xt-mt,O[1]=mt-(xt-I)+(wt-I),Ft=gt+xt,I=Ft-gt,O[2]=gt-(Ft-I)+(xt-I),O[3]=Ft),0===p&&0===g&&0===y&&0===m||(Tt=vt*vt,bt=e*vt,lt=bt-(bt-vt),dt=vt-lt,jt=dt*dt-(Tt-lt*lt-(lt+lt)*dt),wt=Ct*Ct,bt=e*Ct,lt=bt-(bt-Ct),dt=Ct-lt,At=dt*dt-(wt-lt*lt-(lt+lt)*dt),xt=jt+At,I=xt-jt,P[0]=jt-(xt-I)+(At-I),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt+wt,I=xt-mt,P[1]=mt-(xt-I)+(wt-I),Ft=gt+xt,I=Ft-gt,P[2]=gt-(Ft-I)+(xt-I),P[3]=Ft),0!==p&&(j=a(4,J,p,S),d=Mt(d,o(a(j,S,2*kt,st),st,a(a(4,P,p,rt),rt,Bt,ot),ot,a(a(4,O,p,rt),rt,-Ct,at),at,ct,it),it)),0!==g&&(w=a(4,J,g,U),d=Mt(d,o(a(w,U,2*zt,st),st,a(a(4,O,g,rt),rt,vt,ot),ot,a(a(4,P,g,rt),rt,-qt,at),at,ct,it),it)),0!==y&&(A=a(4,K,y,V),d=Mt(d,o(a(A,V,2*qt,st),st,a(a(4,N,y,rt),rt,Ct,ot),ot,a(a(4,P,y,rt),rt,-zt,at),at,ct,it),it)),0!==m&&(F=a(4,K,m,W),d=Mt(d,o(a(F,W,2*Bt,st),st,a(a(4,P,m,rt),rt,kt,ot),ot,a(a(4,N,m,rt),rt,-vt,at),at,ct,it),it)),0!==x&&(k=a(4,L,x,X),d=Mt(d,o(a(k,X,2*vt,st),st,a(a(4,O,x,rt),rt,zt,ot),ot,a(a(4,N,x,rt),rt,-Bt,at),at,ct,it),it)),0!==T&&(q=a(4,L,T,Y),d=Mt(d,o(a(q,Y,2*Ct,st),st,a(a(4,N,T,rt),rt,qt,ot),ot,a(a(4,O,T,rt),rt,-kt,at),at,ct,it),it)),0!==p||0!==g){if(0!==y||0!==m||0!==x||0!==T?(Tt=y*Ct,bt=e*y,lt=bt-(bt-y),dt=y-lt,bt=e*Ct,pt=bt-(bt-Ct),yt=Ct-pt,jt=dt*yt-(Tt-lt*pt-dt*pt-lt*yt),wt=qt*T,bt=e*qt,lt=bt-(bt-qt),dt=qt-lt,bt=e*T,pt=bt-(bt-T),yt=T-pt,At=dt*yt-(wt-lt*pt-dt*pt-lt*yt),xt=jt+At,I=xt-jt,Q[0]=jt-(xt-I)+(At-I),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt+wt,I=xt-mt,Q[1]=mt-(xt-I)+(wt-I),Ft=gt+xt,I=Ft-gt,Q[2]=gt-(Ft-I)+(xt-I),Q[3]=Ft,Tt=x*-Bt,bt=e*x,lt=bt-(bt-x),dt=x-lt,bt=e*-Bt,pt=bt-(bt- -Bt),yt=-Bt-pt,jt=dt*yt-(Tt-lt*pt-dt*pt-lt*yt),wt=vt*-m,bt=e*vt,lt=bt-(bt-vt),dt=vt-lt,bt=e*-m,pt=bt-(bt- -m),yt=-m-pt,At=dt*yt-(wt-lt*pt-dt*pt-lt*yt),xt=jt+At,I=xt-jt,R[0]=jt-(xt-I)+(At-I),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt+wt,I=xt-mt,R[1]=mt-(xt-I)+(wt-I),Ft=gt+xt,I=Ft-gt,R[2]=gt-(Ft-I)+(xt-I),R[3]=Ft,z=s(4,Q,4,R,$),Tt=y*T,bt=e*y,lt=bt-(bt-y),dt=y-lt,bt=e*T,pt=bt-(bt-T),yt=T-pt,jt=dt*yt-(Tt-lt*pt-dt*pt-lt*yt),wt=x*m,bt=e*x,lt=bt-(bt-x),dt=x-lt,bt=e*m,pt=bt-(bt-m),yt=m-pt,At=dt*yt-(wt-lt*pt-dt*pt-lt*yt),xt=jt-At,I=jt-xt,nt[0]=jt-(xt+I)+(I-At),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt-wt,I=mt-xt,nt[1]=mt-(xt+I)+(I-wt),Ft=gt+xt,I=Ft-gt,nt[2]=gt-(Ft-I)+(xt-I),nt[3]=Ft,D=4):($[0]=0,z=1,nt[0]=0,D=1),0!==p){const t=a(z,$,p,at);d=Mt(d,s(a(j,S,p,st),st,a(t,at,2*kt,ct),ct,it),it);const n=a(D,nt,p,rt);d=Mt(d,o(a(n,rt,2*kt,st),st,a(n,rt,p,ot),ot,a(t,at,p,ct),ct,ft,ut),ut),0!==m&&(d=Mt(d,a(a(4,P,p,rt),rt,m,st),st)),0!==T&&(d=Mt(d,a(a(4,O,-p,rt),rt,T,st),st))}if(0!==g){const t=a(z,$,g,at);d=Mt(d,s(a(w,U,g,st),st,a(t,at,2*zt,ct),ct,it),it);const n=a(D,nt,g,rt);d=Mt(d,o(a(n,rt,2*zt,st),st,a(n,rt,g,ot),ot,a(t,at,g,ct),ct,ft,ut),ut)}}if(0!==y||0!==m){if(0!==x||0!==T||0!==p||0!==g?(Tt=x*zt,bt=e*x,lt=bt-(bt-x),dt=x-lt,bt=e*zt,pt=bt-(bt-zt),yt=zt-pt,jt=dt*yt-(Tt-lt*pt-dt*pt-lt*yt),wt=vt*g,bt=e*vt,lt=bt-(bt-vt),dt=vt-lt,bt=e*g,pt=bt-(bt-g),yt=g-pt,At=dt*yt-(wt-lt*pt-dt*pt-lt*yt),xt=jt+At,I=xt-jt,Q[0]=jt-(xt-I)+(At-I),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt+wt,I=xt-mt,Q[1]=mt-(xt-I)+(wt-I),Ft=gt+xt,I=Ft-gt,Q[2]=gt-(Ft-I)+(xt-I),Q[3]=Ft,G=-Ct,H=-T,Tt=p*G,bt=e*p,lt=bt-(bt-p),dt=p-lt,bt=e*G,pt=bt-(bt-G),yt=G-pt,jt=dt*yt-(Tt-lt*pt-dt*pt-lt*yt),wt=kt*H,bt=e*kt,lt=bt-(bt-kt),dt=kt-lt,bt=e*H,pt=bt-(bt-H),yt=H-pt,At=dt*yt-(wt-lt*pt-dt*pt-lt*yt),xt=jt+At,I=xt-jt,R[0]=jt-(xt-I)+(At-I),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt+wt,I=xt-mt,R[1]=mt-(xt-I)+(wt-I),Ft=gt+xt,I=Ft-gt,R[2]=gt-(Ft-I)+(xt-I),R[3]=Ft,B=s(4,Q,4,R,_),Tt=x*g,bt=e*x,lt=bt-(bt-x),dt=x-lt,bt=e*g,pt=bt-(bt-g),yt=g-pt,jt=dt*yt-(Tt-lt*pt-dt*pt-lt*yt),wt=p*T,bt=e*p,lt=bt-(bt-p),dt=p-lt,bt=e*T,pt=bt-(bt-T),yt=T-pt,At=dt*yt-(wt-lt*pt-dt*pt-lt*yt),xt=jt-At,I=jt-xt,et[0]=jt-(xt+I)+(I-At),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt-wt,I=mt-xt,et[1]=mt-(xt+I)+(I-wt),Ft=gt+xt,I=Ft-gt,et[2]=gt-(Ft-I)+(xt-I),et[3]=Ft,E=4):(_[0]=0,B=1,et[0]=0,E=1),0!==y){const t=a(B,_,y,at);d=Mt(d,s(a(A,V,y,st),st,a(t,at,2*qt,ct),ct,it),it);const n=a(E,et,y,rt);d=Mt(d,o(a(n,rt,2*qt,st),st,a(n,rt,y,ot),ot,a(t,at,y,ct),ct,ft,ut),ut),0!==T&&(d=Mt(d,a(a(4,N,y,rt),rt,T,st),st)),0!==g&&(d=Mt(d,a(a(4,P,-y,rt),rt,g,st),st))}if(0!==m){const t=a(B,_,m,at);d=Mt(d,s(a(F,W,m,st),st,a(t,at,2*Bt,ct),ct,it),it);const n=a(E,et,m,rt);d=Mt(d,o(a(n,rt,2*Bt,st),st,a(n,rt,m,ot),ot,a(t,at,m,ct),ct,ft,ut),ut)}}if(0!==x||0!==T){if(0!==p||0!==g||0!==y||0!==m?(Tt=p*Bt,bt=e*p,lt=bt-(bt-p),dt=p-lt,bt=e*Bt,pt=bt-(bt-Bt),yt=Bt-pt,jt=dt*yt-(Tt-lt*pt-dt*pt-lt*yt),wt=kt*m,bt=e*kt,lt=bt-(bt-kt),dt=kt-lt,bt=e*m,pt=bt-(bt-m),yt=m-pt,At=dt*yt-(wt-lt*pt-dt*pt-lt*yt),xt=jt+At,I=xt-jt,Q[0]=jt-(xt-I)+(At-I),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt+wt,I=xt-mt,Q[1]=mt-(xt-I)+(wt-I),Ft=gt+xt,I=Ft-gt,Q[2]=gt-(Ft-I)+(xt-I),Q[3]=Ft,G=-zt,H=-g,Tt=y*G,bt=e*y,lt=bt-(bt-y),dt=y-lt,bt=e*G,pt=bt-(bt-G),yt=G-pt,jt=dt*yt-(Tt-lt*pt-dt*pt-lt*yt),wt=qt*H,bt=e*qt,lt=bt-(bt-qt),dt=qt-lt,bt=e*H,pt=bt-(bt-H),yt=H-pt,At=dt*yt-(wt-lt*pt-dt*pt-lt*yt),xt=jt+At,I=xt-jt,R[0]=jt-(xt-I)+(At-I),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt+wt,I=xt-mt,R[1]=mt-(xt-I)+(wt-I),Ft=gt+xt,I=Ft-gt,R[2]=gt-(Ft-I)+(xt-I),R[3]=Ft,v=s(4,Q,4,R,Z),Tt=p*m,bt=e*p,lt=bt-(bt-p),dt=p-lt,bt=e*m,pt=bt-(bt-m),yt=m-pt,jt=dt*yt-(Tt-lt*pt-dt*pt-lt*yt),wt=y*g,bt=e*y,lt=bt-(bt-y),dt=y-lt,bt=e*g,pt=bt-(bt-g),yt=g-pt,At=dt*yt-(wt-lt*pt-dt*pt-lt*yt),xt=jt-At,I=jt-xt,tt[0]=jt-(xt+I)+(I-At),gt=Tt+xt,I=gt-Tt,mt=Tt-(gt-I)+(xt-I),xt=mt-wt,I=mt-xt,tt[1]=mt-(xt+I)+(I-wt),Ft=gt+xt,I=Ft-gt,tt[2]=gt-(Ft-I)+(xt-I),tt[3]=Ft,C=4):(Z[0]=0,v=1,tt[0]=0,C=1),0!==x){const t=a(v,Z,x,at);d=Mt(d,s(a(k,X,x,st),st,a(t,at,2*vt,ct),ct,it),it);const n=a(C,tt,x,rt);d=Mt(d,o(a(n,rt,2*vt,st),st,a(n,rt,x,ot),ot,a(t,at,x,ct),ct,ft,ut),ut),0!==g&&(d=Mt(d,a(a(4,O,x,rt),rt,g,st),st)),0!==m&&(d=Mt(d,a(a(4,N,-x,rt),rt,m,st),st))}if(0!==T){const t=a(v,Z,T,at);d=Mt(d,s(a(q,Y,T,st),st,a(t,at,2*Ct,ct),ct,it),it);const n=a(C,tt,T,rt);d=Mt(d,o(a(n,rt,2*Ct,st),st,a(n,rt,T,ot),ot,a(t,at,T,ct),ct,ft,ut),ut)}}return ht[d-1]}(t,n,c,i,u,h,b,M,B)},t.incirclefast=function(t,n,e,r,s,o,a,c){const f=t-a,i=n-c,u=e-a,h=r-c,b=s-a,M=o-c;return(f*f+i*i)*(u*M-b*h)+(u*u+h*h)*(b*i-f*M)+(b*b+M*M)*(f*h-u*i)},t.insphere=function(t,n,e,r,s,o,a,c,f,i,u,h,b,M,l){const d=t-b,p=r-b,y=a-b,x=i-b,g=n-M,m=s-M,T=c-M,j=u-M,w=e-l,A=o-l,F=f-l,k=h-l,q=d*m,v=p*g,z=q-v,B=p*T,C=y*m,D=B-C,E=y*j,G=x*T,H=E-G,I=x*g,J=d*j,K=I-J,L=d*T,N=y*g,O=L-N,P=p*j,Q=x*m,R=P-Q,S=d*d+g*g+w*w,U=p*p+m*m+A*A,V=y*y+T*T+F*F,W=x*x+j*j+k*k,X=V*(k*z+w*R+A*K)-W*(w*D-A*O+F*z)+(S*(A*H-F*R+k*D)-U*(F*K+k*O+w*H)),Y=Math.abs(w),Z=Math.abs(A),$=Math.abs(F),_=Math.abs(k),tt=Math.abs(q)+Math.abs(v),nt=Math.abs(B)+Math.abs(C),et=Math.abs(E)+Math.abs(G),rt=Math.abs(I)+Math.abs(J),st=Math.abs(L)+Math.abs(N),ot=Math.abs(P)+Math.abs(Q),at=(et*Z+ot*$+nt*_)*S+(rt*$+st*_+et*Y)*U+(tt*_+ot*Y+rt*Z)*V+(nt*Y+st*Z+tt*$)*W,ct=17763568394002532e-31*at;return X>ct||-X>ct?X:-un(t,n,e,r,s,o,a,c,f,i,u,h,b,M,l,at)},t.inspherefast=function(t,n,e,r,s,o,a,c,f,i,u,h,b,M,l){const d=t-b,p=r-b,y=a-b,x=i-b,g=n-M,m=s-M,T=c-M,j=u-M,w=e-l,A=o-l,F=f-l,k=h-l,q=d*m-p*g,v=p*T-y*m,z=y*j-x*T,B=x*g-d*j,C=d*T-y*g,D=p*j-x*m;return(y*y+T*T+F*F)*(k*q+w*D+A*B)-(x*x+j*j+k*k)*(w*v-A*C+F*q)+((d*d+g*g+w*w)*(A*z-F*D+k*v)-(p*p+m*m+A*A)*(F*B+k*C+w*z))},t.orient2d=function(t,n,o,a,c,i){const d=(n-i)*(o-c),p=(t-c)*(a-i),y=d-p,x=Math.abs(d+p);return Math.abs(y)>=33306690738754716e-32*x?y:-function(t,n,o,a,c,i,d){let p,y,x,g,m,T,j,w,A,F,k,q,v,z,B,C,D,E;const G=t-c,H=o-c,I=n-i,J=a-i;z=G*J,T=e*G,j=T-(T-G),w=G-j,T=e*J,A=T-(T-J),F=J-A,B=w*F-(z-j*A-w*A-j*F),C=I*H,T=e*I,j=T-(T-I),w=I-j,T=e*H,A=T-(T-H),F=H-A,D=w*F-(C-j*A-w*A-j*F),k=B-D,m=B-k,u[0]=B-(k+m)+(m-D),q=z+k,m=q-z,v=z-(q-m)+(k-m),k=v-C,m=v-k,u[1]=v-(k+m)+(m-C),E=q+k,m=E-q,u[2]=q-(E-m)+(k-m),u[3]=E;let K=f(4,u),L=22204460492503146e-32*d;if(K>=L||-K>=L)return K;if(m=t-G,p=t-(G+m)+(m-c),m=o-H,x=o-(H+m)+(m-c),m=n-I,y=n-(I+m)+(m-i),m=a-J,g=a-(J+m)+(m-i),0===p&&0===y&&0===x&&0===g)return K;if(L=11093356479670487e-47*d+r*Math.abs(K),K+=G*g+J*p-(I*x+H*y),K>=L||-K>=L)return K;z=p*J,T=e*p,j=T-(T-p),w=p-j,T=e*J,A=T-(T-J),F=J-A,B=w*F-(z-j*A-w*A-j*F),C=y*H,T=e*y,j=T-(T-y),w=y-j,T=e*H,A=T-(T-H),F=H-A,D=w*F-(C-j*A-w*A-j*F),k=B-D,m=B-k,l[0]=B-(k+m)+(m-D),q=z+k,m=q-z,v=z-(q-m)+(k-m),k=v-C,m=v-k,l[1]=v-(k+m)+(m-C),E=q+k,m=E-q,l[2]=q-(E-m)+(k-m),l[3]=E;const N=s(4,u,4,l,h);z=G*g,T=e*G,j=T-(T-G),w=G-j,T=e*g,A=T-(T-g),F=g-A,B=w*F-(z-j*A-w*A-j*F),C=I*x,T=e*I,j=T-(T-I),w=I-j,T=e*x,A=T-(T-x),F=x-A,D=w*F-(C-j*A-w*A-j*F),k=B-D,m=B-k,l[0]=B-(k+m)+(m-D),q=z+k,m=q-z,v=z-(q-m)+(k-m),k=v-C,m=v-k,l[1]=v-(k+m)+(m-C),E=q+k,m=E-q,l[2]=q-(E-m)+(k-m),l[3]=E;const O=s(N,h,4,l,b);z=p*g,T=e*p,j=T-(T-p),w=p-j,T=e*g,A=T-(T-g),F=g-A,B=w*F-(z-j*A-w*A-j*F),C=y*x,T=e*y,j=T-(T-y),w=y-j,T=e*x,A=T-(T-x),F=x-A,D=w*F-(C-j*A-w*A-j*F),k=B-D,m=B-k,l[0]=B-(k+m)+(m-D),q=z+k,m=q-z,v=z-(q-m)+(k-m),k=v-C,m=v-k,l[1]=v-(k+m)+(m-C),E=q+k,m=E-q,l[2]=q-(E-m)+(k-m),l[3]=E;const P=s(O,b,4,l,M);return M[P-1]}(t,n,o,a,c,i,x)},t.orient2dfast=function(t,n,e,r,s,o){return(n-o)*(e-s)-(t-s)*(r-o)},t.orient3d=function(t,n,o,c,i,u,h,b,M,l,q,E){const J=t-l,K=c-l,L=h-l,N=n-q,O=i-q,P=b-q,Q=o-E,R=u-E,S=M-E,U=K*P,V=L*O,W=L*N,X=J*P,Y=J*O,Z=K*N,$=Q*(U-V)+R*(W-X)+S*(Y-Z),_=(Math.abs(U)+Math.abs(V))*Math.abs(Q)+(Math.abs(W)+Math.abs(X))*Math.abs(R)+(Math.abs(Y)+Math.abs(Z))*Math.abs(S),tt=7771561172376103e-31*_;return $>tt||-$>tt?$:function(t,n,o,c,i,u,h,b,M,l,q,E,J){let K,L,N,O,P,Q,R,S,U,V,W,X,Y,Z,$,_,tt,nt,et,rt,st,ot,at,ct;const ft=t-l,it=c-l,ut=h-l,ht=n-q,bt=i-q,Mt=b-q,lt=o-E,dt=u-E,pt=M-E;rt=it*Mt,X=e*it,Y=X-(X-it),Z=it-Y,X=e*Mt,$=X-(X-Mt),_=Mt-$,st=Z*_-(rt-Y*$-Z*$-Y*_),ot=ut*bt,X=e*ut,Y=X-(X-ut),Z=ut-Y,X=e*bt,$=X-(X-bt),_=bt-$,at=Z*_-(ot-Y*$-Z*$-Y*_),tt=st-at,W=st-tt,d[0]=st-(tt+W)+(W-at),nt=rt+tt,W=nt-rt,et=rt-(nt-W)+(tt-W),tt=et-ot,W=et-tt,d[1]=et-(tt+W)+(W-ot),ct=nt+tt,W=ct-nt,d[2]=nt-(ct-W)+(tt-W),d[3]=ct,rt=ut*ht,X=e*ut,Y=X-(X-ut),Z=ut-Y,X=e*ht,$=X-(X-ht),_=ht-$,st=Z*_-(rt-Y*$-Z*$-Y*_),ot=ft*Mt,X=e*ft,Y=X-(X-ft),Z=ft-Y,X=e*Mt,$=X-(X-Mt),_=Mt-$,at=Z*_-(ot-Y*$-Z*$-Y*_),tt=st-at,W=st-tt,p[0]=st-(tt+W)+(W-at),nt=rt+tt,W=nt-rt,et=rt-(nt-W)+(tt-W),tt=et-ot,W=et-tt,p[1]=et-(tt+W)+(W-ot),ct=nt+tt,W=ct-nt,p[2]=nt-(ct-W)+(tt-W),p[3]=ct,rt=ft*bt,X=e*ft,Y=X-(X-ft),Z=ft-Y,X=e*bt,$=X-(X-bt),_=bt-$,st=Z*_-(rt-Y*$-Z*$-Y*_),ot=it*ht,X=e*it,Y=X-(X-it),Z=it-Y,X=e*ht,$=X-(X-ht),_=ht-$,at=Z*_-(ot-Y*$-Z*$-Y*_),tt=st-at,W=st-tt,y[0]=st-(tt+W)+(W-at),nt=rt+tt,W=nt-rt,et=rt-(nt-W)+(tt-W),tt=et-ot,W=et-tt,y[1]=et-(tt+W)+(W-ot),ct=nt+tt,W=ct-nt,y[2]=nt-(ct-W)+(tt-W),y[3]=ct,K=s(s(a(4,d,lt,v),v,a(4,p,dt,z),z,B),B,a(4,y,pt,v),v,D);let yt=f(K,D),xt=3330669073875473e-31*J;if(yt>=xt||-yt>=xt)return yt;if(W=t-ft,L=t-(ft+W)+(W-l),W=c-it,N=c-(it+W)+(W-l),W=h-ut,O=h-(ut+W)+(W-l),W=n-ht,P=n-(ht+W)+(W-q),W=i-bt,Q=i-(bt+W)+(W-q),W=b-Mt,R=b-(Mt+W)+(W-q),W=o-lt,S=o-(lt+W)+(W-E),W=u-dt,U=u-(dt+W)+(W-E),W=M-pt,V=M-(pt+W)+(W-E),0===L&&0===N&&0===O&&0===P&&0===Q&&0===R&&0===S&&0===U&&0===V)return yt;if(xt=32047474274603644e-47*J+r*Math.abs(yt),yt+=lt*(it*R+Mt*N-(bt*O+ut*Q))+S*(it*Mt-bt*ut)+dt*(ut*P+ht*O-(Mt*L+ft*R))+U*(ut*ht-Mt*ft)+pt*(ft*Q+bt*L-(ht*N+it*P))+V*(ft*bt-ht*it),yt>=xt||-yt>=xt)return yt;const gt=H(L,P,it,bt,ut,Mt,x,g),mt=H(N,Q,ut,Mt,ft,ht,m,T),Tt=H(O,R,ft,ht,it,bt,j,w),jt=s(mt,m,Tt,w,A);K=G(K,a(jt,A,lt,B),B);const wt=s(Tt,j,gt,g,F);K=G(K,a(wt,F,dt,B),B);const At=s(gt,x,mt,T,k);return K=G(K,a(At,k,pt,B),B),0!==S&&(K=G(K,a(4,d,S,C),C),K=G(K,a(jt,A,S,B),B)),0!==U&&(K=G(K,a(4,p,U,C),C),K=G(K,a(wt,F,U,B),B)),0!==V&&(K=G(K,a(4,y,V,C),C),K=G(K,a(At,k,V,B),B)),0!==L&&(0!==Q&&(K=I(K,L,Q,pt,V)),0!==R&&(K=I(K,-L,R,dt,U))),0!==N&&(0!==R&&(K=I(K,N,R,lt,S)),0!==P&&(K=I(K,-N,P,pt,V))),0!==O&&(0!==P&&(K=I(K,O,P,dt,U)),0!==Q&&(K=I(K,-O,Q,lt,S))),D[K-1]}(t,n,o,c,i,u,h,b,M,l,q,E,_)},t.orient3dfast=function(t,n,e,r,s,o,a,c,f,i,u,h){const b=n-u,M=s-u,l=c-u,d=e-h,p=o-h,y=f-h;return(t-i)*(M*y-p*l)+(r-i)*(l*d-y*b)+(a-i)*(b*p-d*M)}});
diff --git a/tools/ui/node_modules/rollup/LICENSE.md b/tools/ui/node_modules/rollup/LICENSE.md
new file mode 100644
index 0000000000000000000000000000000000000000..7b806824370697048284c1726fc4d1b567bfea68
--- /dev/null
+++ b/tools/ui/node_modules/rollup/LICENSE.md
@@ -0,0 +1,679 @@
+# Rollup core license
+Rollup is released under the MIT license:
+
+The MIT License (MIT)
+
+Copyright (c) 2017 [these people](https://github.com/rollup/rollup/graphs/contributors)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Licenses of bundled dependencies
+The published Rollup artifact additionally contains code with the following licenses:
+MIT, ISC, 0BSD
+
+# Bundled dependencies:
+## @jridgewell/sourcemap-codec
+License: MIT
+By: Justin Ridgewell
+Repository: git+https://github.com/jridgewell/sourcemaps.git
+
+> Copyright 2024 Justin Ridgewell 
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## @rollup/pluginutils
+License: MIT
+By: Rich Harris
+Repository: rollup/plugins
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## anymatch
+License: ISC
+By: Elan Shanker
+Repository: https://github.com/micromatch/anymatch
+
+> The ISC License
+> 
+> Copyright (c) 2019 Elan Shanker, Paul Miller (https://paulmillr.com)
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## binary-extensions
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/binary-extensions
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus  (https://sindresorhus.com)
+> Copyright (c) Paul Miller (https://paulmillr.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## braces
+License: MIT
+By: Jon Schlinkert, Brian Woodward, Elan Shanker, Eugene Sharygin, hemanth.hm
+Repository: micromatch/braces
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## builtin-modules
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/builtin-modules
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus  (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## chokidar
+License: MIT
+By: Paul Miller, Elan Shanker
+Repository: git+https://github.com/paulmillr/chokidar.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2012-2019 Paul Miller (https://paulmillr.com), Elan Shanker
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the “Software”), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## date-time
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/date-time
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus  (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## fill-range
+License: MIT
+By: Jon Schlinkert, Edo Rivai, Paul Miller, Rouven Weßling
+Repository: jonschlinkert/fill-range
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## flru
+License: MIT
+By: Luke Edwards
+Repository: lukeed/flru
+
+> MIT License
+> 
+> Copyright (c) Luke Edwards  (lukeed.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## glob-parent
+License: ISC
+By: Gulp Team, Elan Shanker, Blaine Bublitz
+Repository: gulpjs/glob-parent
+
+> The ISC License
+> 
+> Copyright (c) 2015, 2019 Elan Shanker
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## is-binary-path
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/is-binary-path
+
+> MIT License
+> 
+> Copyright (c) 2019 Sindre Sorhus  (https://sindresorhus.com), Paul Miller (https://paulmillr.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## is-extglob
+License: MIT
+By: Jon Schlinkert
+Repository: jonschlinkert/is-extglob
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2016, Jon Schlinkert
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## is-glob
+License: MIT
+By: Jon Schlinkert, Brian Woodward, Daniel Perez
+Repository: micromatch/is-glob
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2017, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## is-number
+License: MIT
+By: Jon Schlinkert, Olsten Larck, Rouven Weßling
+Repository: jonschlinkert/is-number
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## is-reference
+License: MIT
+By: Rich Harris
+Repository: git+https://github.com/Rich-Harris/is-reference.git
+
+---------------------------------------
+
+## locate-character
+License: MIT
+By: Rich Harris
+Repository: git+https://gitlab.com/Rich-Harris/locate-character.git
+
+---------------------------------------
+
+## magic-string
+License: MIT
+By: Rich Harris
+Repository: git+https://github.com/Rich-Harris/magic-string.git
+
+> Copyright 2018 Rich Harris
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## normalize-path
+License: MIT
+By: Jon Schlinkert, Blaine Bublitz
+Repository: jonschlinkert/normalize-path
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2018, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## parse-ms
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/parse-ms
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus  (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## picocolors
+License: ISC
+By: Alexey Raspopov
+Repository: alexeyraspopov/picocolors
+
+> ISC License
+> 
+> Copyright (c) 2021-2024 Oleksii Raspopov, Kostiantyn Denysov, Anton Verinov
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+> OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## picomatch
+License: MIT
+By: Jon Schlinkert
+Repository: micromatch/picomatch
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2017-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## pretty-bytes
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/pretty-bytes
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus  (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## pretty-ms
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/pretty-ms
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus  (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## readdirp
+License: MIT
+By: Thorsten Lorenz, Paul Miller
+Repository: git://github.com/paulmillr/readdirp.git
+
+> MIT License
+> 
+> Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## signal-exit
+License: ISC
+By: Ben Coe
+Repository: https://github.com/tapjs/signal-exit.git
+
+> The ISC License
+> 
+> Copyright (c) 2015-2023 Benjamin Coe, Isaac Z. Schlueter, and Contributors
+> 
+> Permission to use, copy, modify, and/or distribute this software
+> for any purpose with or without fee is hereby granted, provided
+> that the above copyright notice and this permission notice
+> appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+> OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE
+> LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+> OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+> WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+> ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## time-zone
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/time-zone
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus  (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## to-regex-range
+License: MIT
+By: Jon Schlinkert, Rouven Weßling
+Repository: micromatch/to-regex-range
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2015-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## tslib
+License: 0BSD
+By: Microsoft Corp.
+Repository: https://github.com/Microsoft/tslib.git
+
+> Copyright (c) Microsoft Corporation.
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+> REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+> AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+> INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+> LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+> OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+> PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## yargs-parser
+License: ISC
+By: Ben Coe
+Repository: https://github.com/yargs/yargs-parser.git
+
+> Copyright (c) 2016, Contributors
+> 
+> Permission to use, copy, modify, and/or distribute this software
+> for any purpose with or without fee is hereby granted, provided
+> that the above copyright notice and this permission notice
+> appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+> OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE
+> LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+> OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+> WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+> ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/tools/ui/node_modules/rollup/README.md b/tools/ui/node_modules/rollup/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9d9047a9551b28f2d40151171421c6df7504c833
--- /dev/null
+++ b/tools/ui/node_modules/rollup/README.md
@@ -0,0 +1,134 @@
+

+	
+

+
+

+  
+    npm version
+  
+  
+    node compatibility
+  
+  
+    install size
+  
+  
+    code coverage
+  
+  
+    backers
+   
+  
+    sponsors
+   
+  
+    license
+  
+  
+    Join the chat at https://is.gd/rollup_chat
+  
+

+
+
Rollup

+
+## Overview
+
+Rollup is a module bundler for JavaScript which compiles small pieces of code into something larger and more complex, such as a library or application. It uses the standardized ES module format for code, instead of previous idiosyncratic solutions such as CommonJS and AMD. ES modules let you freely and seamlessly combine the most useful individual functions from your favorite libraries. Rollup can optimize ES modules for faster native loading in modern browsers, or output a legacy module format allowing ES module workflows today.
+
+## Quick Start Guide
+
+Install with `npm install --global rollup`. Rollup can be used either through a [command line interface](https://rollupjs.org/command-line-interface/) with an optional configuration file or else through its [JavaScript API](https://rollupjs.org/javascript-api/). Run `rollup --help` to see the available options and parameters. The starter project templates, [rollup-starter-lib](https://github.com/rollup/rollup-starter-lib) and [rollup-starter-app](https://github.com/rollup/rollup-starter-app), demonstrate common configuration options, and more detailed instructions are available throughout the [user guide](https://rollupjs.org/introduction/).
+
+### Commands
+
+These commands assume the entry point to your application is named main.js, and that you'd like all imports compiled into a single file named bundle.js.
+
+For browsers:
+
+```bash
+# compile to a 
+ *
+ * 

+ *   
+ *   
You searched for: {debounced.current}

+ * 

+ */
+export declare class Debounced {
+    #private;
+    /**
+     * @param getter A function that returns the state to watch.
+     * @param wait The length of time to wait in ms, defaults to 250.
+     */
+    constructor(getter: Getter, wait?: MaybeGetter);
+    /**
+     * Get the debounced value.
+     */
+    get current(): T;
+    /**
+     * Whether a timer is currently pending.
+     */
+    get pending(): boolean;
+    /**
+     * Cancel the latest timer.
+     */
+    cancel(): void;
+    /**
+     * Run the debounced function immediately.
+     */
+    updateImmediately(): Promise;
+    /**
+     * Set the `current` value without waiting.
+     */
+    setImmediately(v: T): void;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/debounced/debounced.svelte.js b/tools/ui/node_modules/runed/dist/utilities/debounced/debounced.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..218867ee7010b633d80f08cd74810db87da629b8
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/debounced/debounced.svelte.js
@@ -0,0 +1,78 @@
+import { useDebounce } from "../use-debounce/use-debounce.svelte.js";
+import { watch } from "../watch/watch.svelte.js";
+import { noop } from "../../internal/utils/function.js";
+/**
+ * A wrapper over {@link useDebounce} that creates a debounced state.
+ * It takes a "getter" function which returns the state you want to debounce.
+ * Every time this state changes a timer (re)starts, the length of which is
+ * configurable with the `wait` arg. When the timer ends the `current` value
+ * is updated.
+ *
+ * @see https://runed.dev/docs/utilities/debounced
+ *
+ * @example
+ *
+ * 
+ *
+ * 

+ *   
+ *   
You searched for: {debounced.current}

+ * 

+ */
+export class Debounced {
+    #current = $state();
+    #debounceFn;
+    /**
+     * @param getter A function that returns the state to watch.
+     * @param wait The length of time to wait in ms, defaults to 250.
+     */
+    constructor(getter, wait = 250) {
+        this.#current = getter(); // immediately set the initial value
+        this.cancel = this.cancel.bind(this);
+        this.setImmediately = this.setImmediately.bind(this);
+        this.updateImmediately = this.updateImmediately.bind(this);
+        this.#debounceFn = useDebounce(() => {
+            this.#current = getter();
+        }, wait);
+        watch(getter, () => {
+            this.#debounceFn().catch(noop);
+        });
+    }
+    // isn't the name "current" slightly misleading? it sounds like the latest, raw value
+    /**
+     * Get the debounced value.
+     */
+    get current() {
+        return this.#current;
+    }
+    /**
+     * Whether a timer is currently pending.
+     */
+    get pending() {
+        return this.#debounceFn.pending;
+    }
+    /**
+     * Cancel the latest timer.
+     */
+    cancel() {
+        this.#debounceFn.cancel();
+    }
+    /**
+     * Run the debounced function immediately.
+     */
+    updateImmediately() {
+        return this.#debounceFn.runScheduledNow();
+    }
+    /**
+     * Set the `current` value without waiting.
+     */
+    setImmediately(v) {
+        this.cancel();
+        this.#current = v;
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/debounced/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/debounced/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2d8afc470bd7bbd571ceca2fd1e1762ca9f0e86f
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/debounced/index.d.ts
@@ -0,0 +1 @@
+export * from "./debounced.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/debounced/index.js b/tools/ui/node_modules/runed/dist/utilities/debounced/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..2d8afc470bd7bbd571ceca2fd1e1762ca9f0e86f
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/debounced/index.js
@@ -0,0 +1 @@
+export * from "./debounced.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/element-rect/element-rect.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/element-rect/element-rect.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..809f63d1ec8db5cba918e1e3c39f7e0a95c6ed51
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/element-rect/element-rect.svelte.d.ts
@@ -0,0 +1,31 @@
+import type { MaybeElementGetter, WritableProperties } from "../../internal/types.js";
+import type { ConfigurableWindow } from "../../internal/configurable-globals.js";
+type Rect = WritableProperties>;
+export type ElementRectOptions = ConfigurableWindow & {
+    initialRect?: DOMRect;
+};
+/**
+ * Returns a reactive value holding the size of `node`.
+ *
+ * Accepts an `options` object with the following properties:
+ * - `initialSize`: The initial size of the element. Defaults to `{ width: 0, height: 0 }`.
+ * - `box`: The box model to use. Can be either `"content-box"` or `"border-box"`. Defaults to `"border-box"`.
+ *
+ * @returns an object with `width` and `height` properties.
+ *
+ * @see {@link https://runed.dev/docs/utilities/element-size}
+ */
+export declare class ElementRect {
+    #private;
+    constructor(node: MaybeElementGetter, options?: ElementRectOptions);
+    get x(): number;
+    get y(): number;
+    get width(): number;
+    get height(): number;
+    get top(): number;
+    get right(): number;
+    get bottom(): number;
+    get left(): number;
+    get current(): Rect;
+}
+export {};
diff --git a/tools/ui/node_modules/runed/dist/utilities/element-rect/element-rect.svelte.js b/tools/ui/node_modules/runed/dist/utilities/element-rect/element-rect.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..365dbabcf805856268b18570e7afa698334881d0
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/element-rect/element-rect.svelte.js
@@ -0,0 +1,85 @@
+import { extract } from "../extract/extract.svelte.js";
+import { useMutationObserver } from "../use-mutation-observer/use-mutation-observer.svelte.js";
+import { useResizeObserver } from "../use-resize-observer/use-resize-observer.svelte.js";
+/**
+ * Returns a reactive value holding the size of `node`.
+ *
+ * Accepts an `options` object with the following properties:
+ * - `initialSize`: The initial size of the element. Defaults to `{ width: 0, height: 0 }`.
+ * - `box`: The box model to use. Can be either `"content-box"` or `"border-box"`. Defaults to `"border-box"`.
+ *
+ * @returns an object with `width` and `height` properties.
+ *
+ * @see {@link https://runed.dev/docs/utilities/element-size}
+ */
+export class ElementRect {
+    #rect = $state({
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0,
+        top: 0,
+        right: 0,
+        bottom: 0,
+        left: 0,
+    });
+    constructor(node, options = {}) {
+        this.#rect = {
+            width: options.initialRect?.width ?? 0,
+            height: options.initialRect?.height ?? 0,
+            x: options.initialRect?.x ?? 0,
+            y: options.initialRect?.y ?? 0,
+            top: options.initialRect?.top ?? 0,
+            right: options.initialRect?.right ?? 0,
+            bottom: options.initialRect?.bottom ?? 0,
+            left: options.initialRect?.left ?? 0,
+        };
+        const el = $derived(extract(node));
+        const update = () => {
+            if (!el)
+                return;
+            const rect = el.getBoundingClientRect();
+            this.#rect.width = rect.width;
+            this.#rect.height = rect.height;
+            this.#rect.x = rect.x;
+            this.#rect.y = rect.y;
+            this.#rect.top = rect.top;
+            this.#rect.right = rect.right;
+            this.#rect.bottom = rect.bottom;
+            this.#rect.left = rect.left;
+        };
+        useResizeObserver(() => el, update, { window: options.window });
+        $effect(update);
+        useMutationObserver(() => el, update, {
+            attributeFilter: ["style", "class"],
+            window: options.window,
+        });
+    }
+    get x() {
+        return this.#rect.x;
+    }
+    get y() {
+        return this.#rect.y;
+    }
+    get width() {
+        return this.#rect.width;
+    }
+    get height() {
+        return this.#rect.height;
+    }
+    get top() {
+        return this.#rect.top;
+    }
+    get right() {
+        return this.#rect.right;
+    }
+    get bottom() {
+        return this.#rect.bottom;
+    }
+    get left() {
+        return this.#rect.left;
+    }
+    get current() {
+        return this.#rect;
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/element-rect/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/element-rect/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d66f20780675a7a48e8f8ed4aed017878527ef90
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/element-rect/index.d.ts
@@ -0,0 +1 @@
+export { ElementRect } from "./element-rect.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/element-rect/index.js b/tools/ui/node_modules/runed/dist/utilities/element-rect/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..d66f20780675a7a48e8f8ed4aed017878527ef90
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/element-rect/index.js
@@ -0,0 +1 @@
+export { ElementRect } from "./element-rect.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/element-size/element-size.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/element-size/element-size.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0fcada347f8bc9139cae5442154ea18e68fb9ef3
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/element-size/element-size.svelte.d.ts
@@ -0,0 +1,34 @@
+import { type ConfigurableWindow } from "../../internal/configurable-globals.js";
+import type { MaybeElementGetter } from "../../internal/types.js";
+export type ElementSizeOptions = ConfigurableWindow & {
+    box?: "content-box" | "border-box";
+};
+/**
+ * Returns a reactive value holding the size of `node`.
+ *
+ * Accepts an `options` object with the following properties:
+ * - `initialSize`: The initial size of the element. Defaults to `{ width: 0, height: 0 }`.
+ * - `box`: The box model to use. Can be either `"content-box"` or `"border-box"`. Defaults to `"border-box"`.
+ *
+ * @returns an object with `width` and `height` properties.
+ *
+ * @see {@link https://runed.dev/docs/utilities/element-size}
+ */
+export declare class ElementSize {
+    #private;
+    constructor(node: MaybeElementGetter, options?: ElementSizeOptions);
+    calculateSize(): {
+        width: number;
+        height: number;
+    } | undefined;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    get current(): {
+        width: number;
+        height: number;
+    };
+    get width(): number;
+    get height(): number;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/element-size/element-size.svelte.js b/tools/ui/node_modules/runed/dist/utilities/element-size/element-size.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..7ab36d0d1491335b26db0a9882d83e694f3a3faf
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/element-size/element-size.svelte.js
@@ -0,0 +1,114 @@
+import { defaultWindow } from "../../internal/configurable-globals.js";
+import { get } from "../../internal/utils/get.js";
+import { createSubscriber } from "svelte/reactivity";
+/**
+ * Returns a reactive value holding the size of `node`.
+ *
+ * Accepts an `options` object with the following properties:
+ * - `initialSize`: The initial size of the element. Defaults to `{ width: 0, height: 0 }`.
+ * - `box`: The box model to use. Can be either `"content-box"` or `"border-box"`. Defaults to `"border-box"`.
+ *
+ * @returns an object with `width` and `height` properties.
+ *
+ * @see {@link https://runed.dev/docs/utilities/element-size}
+ */
+export class ElementSize {
+    // no need to use `$state` here since we are using createSubscriber
+    #size = {
+        width: 0,
+        height: 0,
+    };
+    #observed = false;
+    #options;
+    #node;
+    #window;
+    // we use a derived here to extract the width so that if the width doesn't change we don't get a state update
+    // which we would get if we would just use a getter since the version of the subscriber will be changing
+    #width = $derived.by(() => {
+        this.#subscribe?.();
+        return this.getSize().width;
+    });
+    // we use a derived here to extract the height so that if the height doesn't change we don't get a state update
+    // which we would get if we would just use a getter since the version of the subscriber will be changing
+    #height = $derived.by(() => {
+        this.#subscribe?.();
+        return this.getSize().height;
+    });
+    // we need to use a derived here because the class will be created before the node is bound to the ref
+    #subscribe = $derived.by(() => {
+        const node$ = get(this.#node);
+        if (!node$)
+            return;
+        return createSubscriber((update) => {
+            if (!this.#window)
+                return;
+            const observer = new this.#window.ResizeObserver((entries) => {
+                this.#observed = true;
+                for (const entry of entries) {
+                    const boxSize = this.#options.box === "content-box" ? entry.contentBoxSize : entry.borderBoxSize;
+                    const boxSizeArr = Array.isArray(boxSize) ? boxSize : [boxSize];
+                    this.#size.width = boxSizeArr.reduce((acc, size) => Math.max(acc, size.inlineSize), 0);
+                    this.#size.height = boxSizeArr.reduce((acc, size) => Math.max(acc, size.blockSize), 0);
+                }
+                update();
+            });
+            observer.observe(node$);
+            return () => {
+                this.#observed = false;
+                observer.disconnect();
+            };
+        });
+    });
+    constructor(node, options = { box: "border-box" }) {
+        this.#window = options.window ?? defaultWindow;
+        this.#options = options;
+        this.#node = node;
+        this.#size = {
+            width: 0,
+            height: 0,
+        };
+    }
+    calculateSize() {
+        const element = get(this.#node);
+        // no element or no window, return undefined, we will return 0x0 in the getSize method
+        if (!element || !this.#window) {
+            return;
+        }
+        const offsetWidth = element.offsetWidth;
+        const offsetHeight = element.offsetHeight;
+        // easy mode, just return offsets
+        if (this.#options.box === "border-box") {
+            return {
+                width: offsetWidth,
+                height: offsetHeight,
+            };
+        }
+        // hard mode, we need to calculate the content size
+        const style = this.#window.getComputedStyle(element);
+        const paddingWidth = parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);
+        const paddingHeight = parseFloat(style.paddingTop) + parseFloat(style.paddingBottom);
+        const borderWidth = parseFloat(style.borderLeftWidth) + parseFloat(style.borderRightWidth);
+        const borderHeight = parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
+        const contentWidth = offsetWidth - paddingWidth - borderWidth;
+        const contentHeight = offsetHeight - paddingHeight - borderHeight;
+        return {
+            width: contentWidth,
+            height: contentHeight,
+        };
+    }
+    getSize() {
+        // if the resize observer already run we can just return the size
+        // otherwise we calculate the size if possible or we return the initial size
+        return this.#observed ? this.#size : (this.calculateSize() ?? this.#size);
+    }
+    get current() {
+        this.#subscribe?.();
+        return this.getSize();
+    }
+    get width() {
+        return this.#width;
+    }
+    get height() {
+        return this.#height;
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/element-size/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/element-size/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..42f14866cbddb82cb71ea334737bc2e6cdec4f24
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/element-size/index.d.ts
@@ -0,0 +1 @@
+export * from "./element-size.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/element-size/index.js b/tools/ui/node_modules/runed/dist/utilities/element-size/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..42f14866cbddb82cb71ea334737bc2e6cdec4f24
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/element-size/index.js
@@ -0,0 +1 @@
+export * from "./element-size.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/extract/extract.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/extract/extract.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c60724265f9e05a6768193f5c9dccaccfeb91118
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/extract/extract.svelte.d.ts
@@ -0,0 +1,15 @@
+import type { MaybeGetter } from "../../internal/types.js";
+/**
+ * Resolves a value that may be a getter function or a direct value.
+ *
+ * If the input is a function, it will be invoked to retrieve the actual value.
+ * If the resolved value (or the input itself) is `undefined`, the optional
+ * `defaultValue` is returned instead.
+ *
+ * @template T - The expected return type.
+ * @param value - A value or a function that returns a value.
+ * @param defaultValue - A fallback value returned if the resolved value is `undefined`.
+ * @returns The resolved value or the default.
+ */
+export declare function extract(value: MaybeGetter): T;
+export declare function extract(value: MaybeGetter, defaultValue: T): T;
diff --git a/tools/ui/node_modules/runed/dist/utilities/extract/extract.svelte.js b/tools/ui/node_modules/runed/dist/utilities/extract/extract.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..5c3c9e94584559c29ea23e87612d3984f5371062
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/extract/extract.svelte.js
@@ -0,0 +1,13 @@
+import { isFunction } from "../../internal/utils/is.js";
+export function extract(value, defaultValue) {
+    if (isFunction(value)) {
+        const getter = value;
+        const gotten = getter();
+        if (gotten === undefined)
+            return defaultValue;
+        return gotten;
+    }
+    if (value === undefined)
+        return defaultValue;
+    return value;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/extract/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/extract/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1c8f3467b8e26bd2a0695afe904659812ddb39a6
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/extract/index.d.ts
@@ -0,0 +1 @@
+export { extract } from "./extract.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/extract/index.js b/tools/ui/node_modules/runed/dist/utilities/extract/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..1c8f3467b8e26bd2a0695afe904659812ddb39a6
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/extract/index.js
@@ -0,0 +1 @@
+export { extract } from "./extract.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/finite-state-machine/finite-state-machine.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/finite-state-machine/finite-state-machine.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3086815fb812b541d14022370e35783e2b8bd3e9
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/finite-state-machine/finite-state-machine.svelte.d.ts
@@ -0,0 +1,37 @@
+export type FSMLifecycleFn = (meta: LifecycleFnMeta) => void;
+export type LifecycleFnMeta = {
+    from: StatesT | null;
+    to: StatesT;
+    event: EventsT | null;
+    args: unknown;
+};
+export declare function isLifecycleFnMeta(meta: unknown): meta is LifecycleFnMeta;
+export type FSMLifecycle = "_enter" | "_exit";
+export type ActionFn = (...args: unknown[]) => StatesT | void;
+export type Action = StatesT | ActionFn;
+export type StateHandler = {
+    [e in EventsT]?: Action;
+} & {
+    [k in FSMLifecycle]?: FSMLifecycleFn;
+};
+export type Transition = {
+    [s in StatesT]: StateHandler;
+} & {
+    "*"?: StateHandler;
+};
+/**
+ * Defines a strongly-typed finite state machine.
+ *
+ * @see {@link https://runed.dev/docs/utilities/finite-state-machine}
+ */
+export declare class FiniteStateMachine {
+    #private;
+    readonly states: Transition;
+    constructor(initial: StatesT, states: Transition);
+    /** Triggers a new event and returns the new state. */
+    send(event: EventsT, ...args: unknown[]): StatesT;
+    /** Debounces the triggering of an event. */
+    debounce(wait: number | undefined, event: EventsT, ...args: unknown[]): Promise;
+    /** The current state. */
+    get current(): StatesT;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/finite-state-machine/finite-state-machine.svelte.js b/tools/ui/node_modules/runed/dist/utilities/finite-state-machine/finite-state-machine.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..88a721df614730b6a163c320d6912652c2c1d81d
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/finite-state-machine/finite-state-machine.svelte.js
@@ -0,0 +1,78 @@
+export function isLifecycleFnMeta(meta) {
+    return (!!meta &&
+        typeof meta === "object" &&
+        "to" in meta &&
+        "from" in meta &&
+        "event" in meta &&
+        "args" in meta);
+}
+/**
+ * Defines a strongly-typed finite state machine.
+ *
+ * @see {@link https://runed.dev/docs/utilities/finite-state-machine}
+ */
+export class FiniteStateMachine {
+    #current = $state();
+    states;
+    #timeout = {};
+    constructor(initial, states) {
+        this.#current = initial;
+        this.states = states;
+        this.send = this.send.bind(this);
+        this.debounce = this.debounce.bind(this);
+        // synthetically trigger _enter for the initial state.
+        this.#dispatch("_enter", { from: null, to: initial, event: null, args: [] });
+    }
+    #transition(newState, event, args) {
+        const metadata = { from: this.#current, to: newState, event, args };
+        this.#dispatch("_exit", metadata);
+        this.#current = newState;
+        this.#dispatch("_enter", metadata);
+    }
+    #dispatch(event, ...args) {
+        const action = this.states[this.#current]?.[event] ?? this.states["*"]?.[event];
+        if (action instanceof Function) {
+            if (event === "_enter" || event === "_exit") {
+                if (isLifecycleFnMeta(args[0])) {
+                    action(args[0]);
+                }
+                else {
+                    console.warn("Invalid metadata passed to lifecycle function of the FSM.");
+                }
+            }
+            else {
+                return action(...args);
+            }
+        }
+        else if (typeof action === "string") {
+            return action;
+        }
+        else if (event !== "_enter" && event !== "_exit") {
+            console.warn("No action defined for event", event, "in state", this.#current);
+        }
+    }
+    /** Triggers a new event and returns the new state. */
+    send(event, ...args) {
+        const newState = this.#dispatch(event, ...args);
+        if (newState && newState !== this.#current) {
+            this.#transition(newState, event, args);
+        }
+        return this.#current;
+    }
+    /** Debounces the triggering of an event. */
+    async debounce(wait = 500, event, ...args) {
+        if (this.#timeout[event]) {
+            clearTimeout(this.#timeout[event]);
+        }
+        return new Promise((resolve) => {
+            this.#timeout[event] = setTimeout(() => {
+                delete this.#timeout[event];
+                resolve(this.send(event, ...args));
+            }, wait);
+        });
+    }
+    /** The current state. */
+    get current() {
+        return this.#current;
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/finite-state-machine/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/finite-state-machine/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8935ec7dcb34124cd0eb9adfd3b7ffe0978fddea
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/finite-state-machine/index.d.ts
@@ -0,0 +1 @@
+export * from "./finite-state-machine.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/finite-state-machine/index.js b/tools/ui/node_modules/runed/dist/utilities/finite-state-machine/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..8935ec7dcb34124cd0eb9adfd3b7ffe0978fddea
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/finite-state-machine/index.js
@@ -0,0 +1 @@
+export * from "./finite-state-machine.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..55f528b82e6728eda6930051a3cd9d995f8af6b4
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/index.d.ts
@@ -0,0 +1,34 @@
+export * from "./active-element/index.js";
+export * from "./animation-frames/index.js";
+export * from "./context/index.js";
+export * from "./debounced/index.js";
+export * from "./element-rect/index.js";
+export * from "./element-size/index.js";
+export * from "./extract/index.js";
+export * from "./finite-state-machine/index.js";
+export * from "./is-focus-within/index.js";
+export * from "./is-idle/index.js";
+export * from "./is-in-viewport/index.js";
+export * from "./is-mounted/index.js";
+export * from "./is-document-visible/index.js";
+export * from "./on-click-outside/index.js";
+export * from "./persisted-state/index.js";
+export * from "./pressed-keys/index.js";
+export * from "./previous/index.js";
+export * from "./resource/index.js";
+export * from "./scroll-state/index.js";
+export * from "./state-history/index.js";
+export * from "./textarea-autosize/index.js";
+export * from "./throttled/index.js";
+export * from "./use-debounce/index.js";
+export * from "./use-event-listener/index.js";
+export * from "./use-geolocation/index.js";
+export * from "./use-intersection-observer/index.js";
+export * from "./use-mutation-observer/index.js";
+export * from "./use-resize-observer/index.js";
+export * from "./use-interval/index.js";
+export * from "./use-throttle/index.js";
+export * from "./watch/index.js";
+export * from "./scroll-state/index.js";
+export * from "./bool-attr/index.js";
+export * from "./on-cleanup/index.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/index.js b/tools/ui/node_modules/runed/dist/utilities/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..55f528b82e6728eda6930051a3cd9d995f8af6b4
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/index.js
@@ -0,0 +1,34 @@
+export * from "./active-element/index.js";
+export * from "./animation-frames/index.js";
+export * from "./context/index.js";
+export * from "./debounced/index.js";
+export * from "./element-rect/index.js";
+export * from "./element-size/index.js";
+export * from "./extract/index.js";
+export * from "./finite-state-machine/index.js";
+export * from "./is-focus-within/index.js";
+export * from "./is-idle/index.js";
+export * from "./is-in-viewport/index.js";
+export * from "./is-mounted/index.js";
+export * from "./is-document-visible/index.js";
+export * from "./on-click-outside/index.js";
+export * from "./persisted-state/index.js";
+export * from "./pressed-keys/index.js";
+export * from "./previous/index.js";
+export * from "./resource/index.js";
+export * from "./scroll-state/index.js";
+export * from "./state-history/index.js";
+export * from "./textarea-autosize/index.js";
+export * from "./throttled/index.js";
+export * from "./use-debounce/index.js";
+export * from "./use-event-listener/index.js";
+export * from "./use-geolocation/index.js";
+export * from "./use-intersection-observer/index.js";
+export * from "./use-mutation-observer/index.js";
+export * from "./use-resize-observer/index.js";
+export * from "./use-interval/index.js";
+export * from "./use-throttle/index.js";
+export * from "./watch/index.js";
+export * from "./scroll-state/index.js";
+export * from "./bool-attr/index.js";
+export * from "./on-cleanup/index.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-document-visible/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/is-document-visible/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1e1f3205575b15790fa15dd0b0e54c97ad39ee60
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-document-visible/index.d.ts
@@ -0,0 +1 @@
+export * from "./is-document-visible.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-document-visible/index.js b/tools/ui/node_modules/runed/dist/utilities/is-document-visible/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..1e1f3205575b15790fa15dd0b0e54c97ad39ee60
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-document-visible/index.js
@@ -0,0 +1 @@
+export * from "./is-document-visible.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-document-visible/is-document-visible.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/is-document-visible/is-document-visible.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fc7e52042d8d978e23e5e01588ed37907e0cc2a4
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-document-visible/is-document-visible.svelte.d.ts
@@ -0,0 +1,14 @@
+import { type ConfigurableDocument, type ConfigurableWindow } from "../../internal/configurable-globals.js";
+export type IsDocumentVisibleOptions = ConfigurableWindow & ConfigurableDocument;
+/**
+ * Tracks whether the current document is visible (i.e., not hidden).
+ * It listens to the "visibilitychange" event and updates reactively.
+ *
+ * @see {@link https://developer.mozilla.org/docs/Web/API/Document/visibilitychange_event}
+ * @see {@link https://runed.dev/docs/utilities/is-document-visible}
+ */
+export declare class IsDocumentVisible {
+    #private;
+    constructor(options?: IsDocumentVisibleOptions);
+    get current(): boolean;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-document-visible/is-document-visible.svelte.js b/tools/ui/node_modules/runed/dist/utilities/is-document-visible/is-document-visible.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..407c2411e18a00ff437b5265c5f597d7bf7e6c8f
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-document-visible/is-document-visible.svelte.js
@@ -0,0 +1,27 @@
+import { defaultWindow, } from "../../internal/configurable-globals.js";
+import { on } from "svelte/events";
+/**
+ * Tracks whether the current document is visible (i.e., not hidden).
+ * It listens to the "visibilitychange" event and updates reactively.
+ *
+ * @see {@link https://developer.mozilla.org/docs/Web/API/Document/visibilitychange_event}
+ * @see {@link https://runed.dev/docs/utilities/is-document-visible}
+ */
+export class IsDocumentVisible {
+    #visible = $state(false);
+    constructor(options = {}) {
+        const window = options.window ?? defaultWindow;
+        const document = options.document ?? window?.document;
+        this.#visible = document ? !document.hidden : false;
+        $effect(() => {
+            if (!document)
+                return;
+            return on(document, "visibilitychange", () => {
+                this.#visible = !document.hidden;
+            });
+        });
+    }
+    get current() {
+        return this.#visible;
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-focus-within/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/is-focus-within/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ee30c5d33feb57bc2be6db954e0208281862fa5f
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-focus-within/index.d.ts
@@ -0,0 +1 @@
+export * from "./is-focus-within.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-focus-within/index.js b/tools/ui/node_modules/runed/dist/utilities/is-focus-within/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..ee30c5d33feb57bc2be6db954e0208281862fa5f
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-focus-within/index.js
@@ -0,0 +1 @@
+export * from "./is-focus-within.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-focus-within/is-focus-within.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/is-focus-within/is-focus-within.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4425797eec2ae230b6a6c0a723d11ddf8752fb59
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-focus-within/is-focus-within.svelte.d.ts
@@ -0,0 +1,13 @@
+import type { MaybeElementGetter } from "../../internal/types.js";
+import { type ActiveElementOptions } from "../active-element/active-element.svelte.js";
+export interface IsFocusWithinOptions extends ActiveElementOptions {
+}
+/**
+ * Tracks whether the focus is within a target element.
+ * @see {@link https://runed.dev/docs/utilities/is-focus-within}
+ */
+export declare class IsFocusWithin {
+    #private;
+    constructor(node: MaybeElementGetter, options?: IsFocusWithinOptions);
+    readonly current: boolean;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-focus-within/is-focus-within.svelte.js b/tools/ui/node_modules/runed/dist/utilities/is-focus-within/is-focus-within.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..ab8ef14858e33e8ec01f7772f7fa2f27a7083a1a
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-focus-within/is-focus-within.svelte.js
@@ -0,0 +1,20 @@
+import { ActiveElement, } from "../active-element/active-element.svelte.js";
+import { extract } from "../extract/extract.svelte.js";
+/**
+ * Tracks whether the focus is within a target element.
+ * @see {@link https://runed.dev/docs/utilities/is-focus-within}
+ */
+export class IsFocusWithin {
+    #node;
+    #activeElement;
+    constructor(node, options = {}) {
+        this.#node = node;
+        this.#activeElement = new ActiveElement(options);
+    }
+    current = $derived.by(() => {
+        const node = extract(this.#node);
+        if (node == null)
+            return false;
+        return node.contains(this.#activeElement.current);
+    });
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-idle/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/is-idle/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8229534a546fc78b44134172b38bc7248b9df70e
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-idle/index.d.ts
@@ -0,0 +1 @@
+export * from "./is-idle.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-idle/index.js b/tools/ui/node_modules/runed/dist/utilities/is-idle/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..8229534a546fc78b44134172b38bc7248b9df70e
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-idle/index.js
@@ -0,0 +1 @@
+export * from "./is-idle.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-idle/is-idle.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/is-idle/is-idle.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6d11b94947712c5363e6af2c8a7126746c8afa19
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-idle/is-idle.svelte.d.ts
@@ -0,0 +1,38 @@
+import type { MaybeGetter } from "../../internal/types.js";
+import { type ConfigurableDocument, type ConfigurableWindow } from "../../internal/configurable-globals.js";
+export type IsIdleOptions = ConfigurableDocument & ConfigurableWindow & {
+    /**
+     * The events that should set the idle state to `true`
+     *
+     * @default ['mousemove', 'mousedown', 'resize', 'keydown', 'touchstart', 'wheel']
+     */
+    events?: MaybeGetter<(keyof WindowEventMap)[]>;
+    /**
+     * The timeout in milliseconds before the idle state is set to `true`. Defaults to 60 seconds.
+     *
+     * @default 60000
+     */
+    timeout?: MaybeGetter;
+    /**
+     * Detect document visibility changes
+     *
+     * @default false
+     */
+    detectVisibilityChanges?: MaybeGetter;
+    /**
+     * The initial state of the idle property
+     *
+     * @default false
+     */
+    initialState?: boolean;
+};
+/**
+ * Tracks whether the user is being inactive.
+ * @see {@link https://runed.dev/docs/utilities/is-idle}
+ */
+export declare class IsIdle {
+    #private;
+    constructor(_options?: IsIdleOptions);
+    get lastActive(): number;
+    get current(): boolean;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-idle/is-idle.svelte.js b/tools/ui/node_modules/runed/dist/utilities/is-idle/is-idle.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..be24c71d476b34467ef7e425b3fc94913180fef1
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-idle/is-idle.svelte.js
@@ -0,0 +1,63 @@
+import { extract } from "../extract/index.js";
+import { useDebounce } from "../use-debounce/index.js";
+import { useEventListener } from "../use-event-listener/use-event-listener.svelte.js";
+import { defaultWindow, } from "../../internal/configurable-globals.js";
+const DEFAULT_EVENTS = [
+    "keypress",
+    "mousemove",
+    "touchmove",
+    "click",
+    "scroll",
+];
+const DEFAULT_OPTIONS = {
+    events: DEFAULT_EVENTS,
+    initialState: false,
+    timeout: 60000,
+};
+/**
+ * Tracks whether the user is being inactive.
+ * @see {@link https://runed.dev/docs/utilities/is-idle}
+ */
+export class IsIdle {
+    #current = $state(false);
+    #lastActive = $state(Date.now());
+    constructor(_options) {
+        const opts = {
+            ...DEFAULT_OPTIONS,
+            ..._options,
+        };
+        const window = opts.window ?? defaultWindow;
+        const document = opts.document ?? window?.document;
+        const timeout = $derived(extract(opts.timeout));
+        const events = $derived(extract(opts.events));
+        const detectVisibilityChanges = $derived(extract(opts.detectVisibilityChanges));
+        this.#current = opts.initialState;
+        const debouncedReset = useDebounce(() => {
+            this.#current = true;
+        }, () => timeout);
+        debouncedReset();
+        const handleActivity = () => {
+            this.#current = false;
+            this.#lastActive = Date.now();
+            debouncedReset();
+        };
+        useEventListener(() => window, () => events, () => {
+            handleActivity();
+        }, { passive: true });
+        $effect(() => {
+            if (!detectVisibilityChanges || !document)
+                return;
+            useEventListener(document, ["visibilitychange"], () => {
+                if (document.hidden)
+                    return;
+                handleActivity();
+            });
+        });
+    }
+    get lastActive() {
+        return this.#lastActive;
+    }
+    get current() {
+        return this.#current;
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-in-viewport/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/is-in-viewport/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b0ee7bc8bc6c6289d25e84288ece423f17b64d70
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-in-viewport/index.d.ts
@@ -0,0 +1 @@
+export * from "./is-in-viewport.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-in-viewport/index.js b/tools/ui/node_modules/runed/dist/utilities/is-in-viewport/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..b0ee7bc8bc6c6289d25e84288ece423f17b64d70
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-in-viewport/index.js
@@ -0,0 +1 @@
+export * from "./is-in-viewport.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-in-viewport/is-in-viewport.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/is-in-viewport/is-in-viewport.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5db751e2f592043031e451ceca94b9b3d6570ee5
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-in-viewport/is-in-viewport.svelte.d.ts
@@ -0,0 +1,14 @@
+import type { ConfigurableWindow } from "../../internal/configurable-globals.js";
+import type { MaybeElementGetter } from "../../internal/types.js";
+import { type UseIntersectionObserverOptions } from "../use-intersection-observer/use-intersection-observer.svelte.js";
+export type IsInViewportOptions = ConfigurableWindow & UseIntersectionObserverOptions;
+/**
+ * Tracks if an element is visible within the current viewport.
+ *
+ * @see {@link https://runed.dev/docs/utilities/is-in-viewport}
+ */
+export declare class IsInViewport {
+    #private;
+    constructor(node: MaybeElementGetter, options?: IsInViewportOptions);
+    get current(): boolean;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-in-viewport/is-in-viewport.svelte.js b/tools/ui/node_modules/runed/dist/utilities/is-in-viewport/is-in-viewport.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..873b9dcf5645dab56e0c979a70d0c45569cf4a73
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-in-viewport/is-in-viewport.svelte.js
@@ -0,0 +1,25 @@
+import { useIntersectionObserver, } from "../use-intersection-observer/use-intersection-observer.svelte.js";
+/**
+ * Tracks if an element is visible within the current viewport.
+ *
+ * @see {@link https://runed.dev/docs/utilities/is-in-viewport}
+ */
+export class IsInViewport {
+    #isInViewport = $state(false);
+    constructor(node, options) {
+        useIntersectionObserver(node, (intersectionObserverEntries) => {
+            let isIntersecting = this.#isInViewport;
+            let latestTime = 0;
+            for (const entry of intersectionObserverEntries) {
+                if (entry.time >= latestTime) {
+                    latestTime = entry.time;
+                    isIntersecting = entry.isIntersecting;
+                }
+            }
+            this.#isInViewport = isIntersecting;
+        }, options);
+    }
+    get current() {
+        return this.#isInViewport;
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-mounted/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/is-mounted/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c573eaaf0f24f0bbea130330c640886c1ee875e0
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-mounted/index.d.ts
@@ -0,0 +1 @@
+export * from "./is-mounted.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-mounted/index.js b/tools/ui/node_modules/runed/dist/utilities/is-mounted/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..c573eaaf0f24f0bbea130330c640886c1ee875e0
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-mounted/index.js
@@ -0,0 +1 @@
+export * from "./is-mounted.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-mounted/is-mounted.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/is-mounted/is-mounted.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5ce167152a074e1b8892da99fe63b5535db07102
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-mounted/is-mounted.svelte.d.ts
@@ -0,0 +1,11 @@
+/**
+ * Returns an object with the mounted state of the component
+ * that invokes this function.
+ *
+ * @see {@link https://runed.dev/docs/utilities/is-mounted}
+ */
+export declare class IsMounted {
+    #private;
+    constructor();
+    get current(): boolean;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/is-mounted/is-mounted.svelte.js b/tools/ui/node_modules/runed/dist/utilities/is-mounted/is-mounted.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb7a3111f28955e3b92f131cd90a35526b93ccdd
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/is-mounted/is-mounted.svelte.js
@@ -0,0 +1,21 @@
+import { untrack } from "svelte";
+/**
+ * Returns an object with the mounted state of the component
+ * that invokes this function.
+ *
+ * @see {@link https://runed.dev/docs/utilities/is-mounted}
+ */
+export class IsMounted {
+    #isMounted = $state(false);
+    constructor() {
+        $effect(() => {
+            untrack(() => (this.#isMounted = true));
+            return () => {
+                this.#isMounted = false;
+            };
+        });
+    }
+    get current() {
+        return this.#isMounted;
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/on-cleanup/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/on-cleanup/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e8e92de6924e8acc2709921865ed1a7cef2918d8
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/on-cleanup/index.d.ts
@@ -0,0 +1 @@
+export { onCleanup } from "./on-cleanup.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/on-cleanup/index.js b/tools/ui/node_modules/runed/dist/utilities/on-cleanup/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..e8e92de6924e8acc2709921865ed1a7cef2918d8
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/on-cleanup/index.js
@@ -0,0 +1 @@
+export { onCleanup } from "./on-cleanup.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/on-cleanup/on-cleanup.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/on-cleanup/on-cleanup.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fb278b178629155dbcef0d2d6ef8b9af42121ad9
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/on-cleanup/on-cleanup.svelte.d.ts
@@ -0,0 +1,9 @@
+/**
+ * Register a cleanup function that will be called when the current effect context is disposed,
+ * which could be when a component is destroyed or when a root effect is disposed.
+ *
+ * @see {@link https://runed.dev/docs/utilities/on-cleanup}
+ *
+ * @param cb - The cleanup function to register.
+ */
+export declare function onCleanup(cb: () => void): void;
diff --git a/tools/ui/node_modules/runed/dist/utilities/on-cleanup/on-cleanup.svelte.js b/tools/ui/node_modules/runed/dist/utilities/on-cleanup/on-cleanup.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..293ad03eaa5773b3e6ca2b97b7b313016952cddc
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/on-cleanup/on-cleanup.svelte.js
@@ -0,0 +1,15 @@
+/**
+ * Register a cleanup function that will be called when the current effect context is disposed,
+ * which could be when a component is destroyed or when a root effect is disposed.
+ *
+ * @see {@link https://runed.dev/docs/utilities/on-cleanup}
+ *
+ * @param cb - The cleanup function to register.
+ */
+export function onCleanup(cb) {
+    $effect(() => {
+        return () => {
+            cb();
+        };
+    });
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/on-click-outside/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/on-click-outside/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e83b9fe4f3a1b0aca68648e60a91097b93ac7f33
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/on-click-outside/index.d.ts
@@ -0,0 +1 @@
+export * from "./on-click-outside.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/on-click-outside/index.js b/tools/ui/node_modules/runed/dist/utilities/on-click-outside/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..e83b9fe4f3a1b0aca68648e60a91097b93ac7f33
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/on-click-outside/index.js
@@ -0,0 +1 @@
+export * from "./on-click-outside.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/on-click-outside/on-click-outside.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/on-click-outside/on-click-outside.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6a451b7e0ac46aa665dd5a80b894616132c798da
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/on-click-outside/on-click-outside.svelte.d.ts
@@ -0,0 +1,63 @@
+import { type ConfigurableDocument, type ConfigurableWindow } from "../../internal/configurable-globals.js";
+import type { MaybeElementGetter } from "../../internal/types.js";
+export type OnClickOutsideOptions = ConfigurableWindow & ConfigurableDocument & {
+    /**
+     * Whether the click outside handler is enabled by default or not.
+     * If set to false, the handler will not be active until enabled by
+     * calling the returned `start` function
+     *
+     * @default true
+     */
+    immediate?: boolean;
+    /**
+     * Controls whether focus events from iframes trigger the callback.
+     *
+     * Since iframe click events don't bubble to the parent document,
+     * you may want to enable this if you need to detect when users
+     * interact with iframe content.
+     *
+     * @default false
+     */
+    detectIframe?: boolean;
+};
+/**
+ * A utility that calls a given callback when a click event occurs outside of
+ * a specified container element.
+ *
+ * @template T - The type of the container element, defaults to HTMLElement.
+ * @param {MaybeElementGetter} container - The container element or a getter function that returns the container element.
+ * @param {() => void} callback - The callback function to call when a click event occurs outside of the container.
+ * @param {OnClickOutsideOptions} [opts={}] - Optional configuration object.
+ * @param {ConfigurableDocument} [opts.document=defaultDocument] - The document object to use, defaults to the global document.
+ * @param {boolean} [opts.immediate=true] - Whether the click outside handler is enabled by default or not.
+ * @param {boolean} [opts.detectIframe=false] - Controls whether focus events from iframes trigger the callback.
+ *
+ * @example
+ * ```svelte
+ * 
+ *
+ * 

+ *  Inside
+ * 

+ * 
+ * 
+ * 
+ * Enabled: {clickOutside.enabled}
+ *```
+ * @see {@link https://runed.dev/docs/utilities/on-click-outside}
+ */
+export declare function onClickOutside(container: MaybeElementGetter, callback: (event: PointerEvent | FocusEvent) => void, opts?: OnClickOutsideOptions): {
+    /** Stop listening for click events outside the container. */
+    stop: () => boolean;
+    /** Start listening for click events outside the container. */
+    start: () => boolean;
+    /** Whether the click outside handler is currently enabled or not. */
+    readonly enabled: boolean;
+};
diff --git a/tools/ui/node_modules/runed/dist/utilities/on-click-outside/on-click-outside.svelte.js b/tools/ui/node_modules/runed/dist/utilities/on-click-outside/on-click-outside.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..f0676a36a12c980e729a2bc88b836b71635c5b39
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/on-click-outside/on-click-outside.svelte.js
@@ -0,0 +1,182 @@
+import { defaultWindow, } from "../../internal/configurable-globals.js";
+import { getActiveElement, getOwnerDocument, isOrContainsTarget } from "../../internal/utils/dom.js";
+import { noop } from "../../internal/utils/function.js";
+import { isElement } from "../../internal/utils/is.js";
+import { sleep } from "../../internal/utils/sleep.js";
+import { on } from "svelte/events";
+import { extract } from "../extract/extract.svelte.js";
+import { useDebounce } from "../use-debounce/use-debounce.svelte.js";
+import { watch } from "../watch/watch.svelte.js";
+/**
+ * A utility that calls a given callback when a click event occurs outside of
+ * a specified container element.
+ *
+ * @template T - The type of the container element, defaults to HTMLElement.
+ * @param {MaybeElementGetter} container - The container element or a getter function that returns the container element.
+ * @param {() => void} callback - The callback function to call when a click event occurs outside of the container.
+ * @param {OnClickOutsideOptions} [opts={}] - Optional configuration object.
+ * @param {ConfigurableDocument} [opts.document=defaultDocument] - The document object to use, defaults to the global document.
+ * @param {boolean} [opts.immediate=true] - Whether the click outside handler is enabled by default or not.
+ * @param {boolean} [opts.detectIframe=false] - Controls whether focus events from iframes trigger the callback.
+ *
+ * @example
+ * ```svelte
+ * 
+ *
+ * 

+ *  Inside
+ * 

+ * 
+ * 
+ * 
+ * Enabled: {clickOutside.enabled}
+ *```
+ * @see {@link https://runed.dev/docs/utilities/on-click-outside}
+ */
+export function onClickOutside(container, callback, opts = {}) {
+    const { window = defaultWindow, immediate = true, detectIframe = false } = opts;
+    const document = opts.document ?? window?.document;
+    const node = $derived(extract(container));
+    const nodeOwnerDocument = $derived(getOwnerDocument(node, document));
+    let enabled = $state(immediate);
+    let pointerDownIntercepted = false;
+    let removeClickListener = noop;
+    let removeListeners = noop;
+    const handleClickOutside = useDebounce((e) => {
+        if (!node || !nodeOwnerDocument) {
+            removeClickListener();
+            return;
+        }
+        if (pointerDownIntercepted === true || !isValidEvent(e, node, nodeOwnerDocument)) {
+            removeClickListener();
+            return;
+        }
+        if (e.pointerType === "touch") {
+            /**
+             * If the pointer type is touch, we add a listener to wait for the click
+             * event that will follow the pointerdown event if the user interacts in a way
+             * that would trigger a click event.
+             *
+             * This prevents us from prematurely calling the callback if the user is simply
+             * scrolling or dragging the page.
+             */
+            removeClickListener();
+            removeClickListener = on(nodeOwnerDocument, "click", () => callback(e), {
+                once: true,
+            });
+        }
+        else {
+            /**
+             * If the pointer type is not touch, we can directly call the callback function
+             * as the interaction is likely a mouse or pen input which does not require
+             * additional handling.
+             */
+            callback(e);
+        }
+    }, 10);
+    function addListeners() {
+        if (!nodeOwnerDocument || !window || !node)
+            return noop;
+        const events = [
+            /**
+             * CAPTURE INTERACTION START
+             * Mark the pointerdown event as intercepted to indicate that an interaction
+             * has started. This helps in distinguishing between valid and invalid events.
+             */
+            on(nodeOwnerDocument, "pointerdown", (e) => {
+                if (isValidEvent(e, node, nodeOwnerDocument)) {
+                    pointerDownIntercepted = true;
+                }
+            }, { capture: true }),
+            /**
+             * BUBBLE INTERACTION START
+             * Mark the pointerdown event as non-intercepted. Debounce `handleClickOutside` to
+             * avoid prematurely checking if other events were intercepted.
+             */
+            on(nodeOwnerDocument, "pointerdown", (e) => {
+                pointerDownIntercepted = false;
+                handleClickOutside(e);
+            }),
+        ];
+        if (detectIframe) {
+            events.push(
+            /**
+             * DETECT IFRAME INTERACTIONS
+             *
+             * We add a blur event listener to the window to detect when the user
+             * interacts with an iframe. If the active element is an iframe and it
+             * is not a descendant of the container, we call the callback function.
+             */
+            on(window, "blur", async (e) => {
+                await sleep();
+                const activeElement = getActiveElement(nodeOwnerDocument);
+                if (activeElement?.tagName === "IFRAME" && !isOrContainsTarget(node, activeElement)) {
+                    callback(e);
+                }
+            }));
+        }
+        return () => {
+            for (const event of events) {
+                event();
+            }
+        };
+    }
+    function cleanup() {
+        pointerDownIntercepted = false;
+        handleClickOutside.cancel();
+        removeClickListener();
+        removeListeners();
+    }
+    watch([() => enabled, () => node], ([enabled$, node$]) => {
+        if (enabled$ && node$) {
+            removeListeners();
+            removeListeners = addListeners();
+        }
+        else {
+            cleanup();
+        }
+    });
+    $effect(() => {
+        return () => {
+            cleanup();
+        };
+    });
+    return {
+        /** Stop listening for click events outside the container. */
+        stop: () => (enabled = false),
+        /** Start listening for click events outside the container. */
+        start: () => (enabled = true),
+        /** Whether the click outside handler is currently enabled or not. */
+        get enabled() {
+            return enabled;
+        },
+    };
+}
+function isValidEvent(e, container, defaultDocument) {
+    if ("button" in e && e.button > 0)
+        return false;
+    const target = e.target;
+    if (!isElement(target))
+        return false;
+    const ownerDocument = getOwnerDocument(target, defaultDocument);
+    if (!ownerDocument)
+        return false;
+    // handle the case where a user may have pressed a pseudo element by
+    // checking the bounding rect of the container
+    if (target === container) {
+        const rect = container.getBoundingClientRect();
+        const wasInsideClick = rect.top <= e.clientY &&
+            e.clientY <= rect.top + rect.height &&
+            rect.left <= e.clientX &&
+            e.clientX <= rect.left + rect.width;
+        return !wasInsideClick;
+    }
+    return ownerDocument.documentElement.contains(target) && !isOrContainsTarget(container, target);
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/persisted-state/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/persisted-state/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..062847f8f6ed8dbc4ff2d684a953e6b3bb67bce8
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/persisted-state/index.d.ts
@@ -0,0 +1 @@
+export * from "./persisted-state.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/persisted-state/index.js b/tools/ui/node_modules/runed/dist/utilities/persisted-state/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..062847f8f6ed8dbc4ff2d684a953e6b3bb67bce8
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/persisted-state/index.js
@@ -0,0 +1 @@
+export * from "./persisted-state.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/persisted-state/persisted-state.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/persisted-state/persisted-state.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..84f1d33d88a8be3eb087c258f5fd49bceb1e4a98
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/persisted-state/persisted-state.svelte.d.ts
@@ -0,0 +1,29 @@
+import { type ConfigurableWindow } from "../../internal/configurable-globals.js";
+type Serializer = {
+    serialize: (value: T) => string;
+    deserialize: (value: string) => T | undefined;
+};
+type StorageType = "local" | "session";
+type PersistedStateOptions = {
+    /** The storage type to use. Defaults to `local`. */
+    storage?: StorageType;
+    /** The serializer to use. Defaults to `JSON.stringify` and `JSON.parse`. */
+    serializer?: Serializer;
+    /** Whether to sync with the state changes from other tabs. Defaults to `true`. */
+    syncTabs?: boolean;
+} & ConfigurableWindow;
+/**
+ * Creates reactive state that is persisted and synchronized across browser sessions and tabs using Web Storage.
+ * @param key The unique key used to store the state in the storage.
+ * @param initialValue The initial value of the state if not already present in the storage.
+ * @param options Configuration options including storage type, serializer for complex data types, and whether to sync state changes across tabs.
+ *
+ * @see {@link https://runed.dev/docs/utilities/persisted-state}
+ */
+export declare class PersistedState {
+    #private;
+    constructor(key: string, initialValue: T, options?: PersistedStateOptions);
+    get current(): T;
+    set current(newValue: T);
+}
+export {};
diff --git a/tools/ui/node_modules/runed/dist/utilities/persisted-state/persisted-state.svelte.js b/tools/ui/node_modules/runed/dist/utilities/persisted-state/persisted-state.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..5afa920fe877828e71fbd3124cdf9b94a8d4e68d
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/persisted-state/persisted-state.svelte.js
@@ -0,0 +1,117 @@
+import { defaultWindow } from "../../internal/configurable-globals.js";
+import { on } from "svelte/events";
+import { createSubscriber } from "svelte/reactivity";
+function getStorage(storageType, window) {
+    switch (storageType) {
+        case "local":
+            return window.localStorage;
+        case "session":
+            return window.sessionStorage;
+    }
+}
+function proxy(value, root, proxies, subscribe, update, serialize) {
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== null && proto !== Object.prototype && !Array.isArray(value)) {
+        return value;
+    }
+    let p = proxies.get(value);
+    if (!p) {
+        p = new Proxy(value, {
+            get: (target, property) => {
+                subscribe?.();
+                return proxy(Reflect.get(target, property), root, proxies, subscribe, update, serialize);
+            },
+            set: (target, property, value) => {
+                update?.();
+                Reflect.set(target, property, value);
+                serialize(root);
+                return true;
+            },
+        });
+        proxies.set(value, p);
+    }
+    return p;
+}
+/**
+ * Creates reactive state that is persisted and synchronized across browser sessions and tabs using Web Storage.
+ * @param key The unique key used to store the state in the storage.
+ * @param initialValue The initial value of the state if not already present in the storage.
+ * @param options Configuration options including storage type, serializer for complex data types, and whether to sync state changes across tabs.
+ *
+ * @see {@link https://runed.dev/docs/utilities/persisted-state}
+ */
+export class PersistedState {
+    #current;
+    #key;
+    #serializer;
+    #storage;
+    #subscribe;
+    #update;
+    #proxies = new WeakMap();
+    constructor(key, initialValue, options = {}) {
+        const { storage: storageType = "local", serializer = { serialize: JSON.stringify, deserialize: JSON.parse }, syncTabs = true, } = options;
+        const window = "window" in options ? options.window : defaultWindow; // window is not mockable to be undefined without this, because JavaScript will fill undefined with `= default`
+        this.#current = initialValue;
+        this.#key = key;
+        this.#serializer = serializer;
+        if (window === undefined)
+            return;
+        const storage = getStorage(storageType, window);
+        this.#storage = storage;
+        const existingValue = storage.getItem(key);
+        if (existingValue !== null) {
+            this.#current = this.#deserialize(existingValue);
+        }
+        else {
+            this.#serialize(initialValue);
+        }
+        this.#subscribe = createSubscriber((update) => {
+            this.#update = update;
+            const cleanup = syncTabs && storageType === "local"
+                ? on(window, "storage", this.#handleStorageEvent)
+                : null;
+            return () => {
+                cleanup?.();
+                this.#update = undefined;
+            };
+        });
+    }
+    get current() {
+        this.#subscribe?.();
+        const storageItem = this.#storage?.getItem(this.#key);
+        const root = storageItem ? this.#deserialize(storageItem) : this.#current;
+        return proxy(root, root, this.#proxies, this.#subscribe?.bind(this), this.#update?.bind(this), this.#serialize.bind(this));
+    }
+    set current(newValue) {
+        this.#serialize(newValue);
+        this.#update?.();
+    }
+    #handleStorageEvent = (event) => {
+        if (event.key !== this.#key || event.newValue === null)
+            return;
+        this.#current = this.#deserialize(event.newValue);
+        this.#update?.();
+    };
+    #deserialize(value) {
+        try {
+            return this.#serializer.deserialize(value);
+        }
+        catch (error) {
+            console.error(`Error when parsing "${value}" from persisted store "${this.#key}"`, error);
+            return;
+        }
+    }
+    #serialize(value) {
+        try {
+            if (value != undefined) {
+                this.#storage?.setItem(this.#key, this.#serializer.serialize(value));
+            }
+        }
+        catch (error) {
+            console.error(`Error when writing value from persisted store "${this.#key}" to ${this.#storage}`, error);
+        }
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/pressed-keys/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/pressed-keys/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8cb62f38dfe730ed6f31d39c6e3c8e45eaf46ed5
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/pressed-keys/index.d.ts
@@ -0,0 +1 @@
+export { PressedKeys } from "./pressed-keys.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/pressed-keys/index.js b/tools/ui/node_modules/runed/dist/utilities/pressed-keys/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..8cb62f38dfe730ed6f31d39c6e3c8e45eaf46ed5
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/pressed-keys/index.js
@@ -0,0 +1 @@
+export { PressedKeys } from "./pressed-keys.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/pressed-keys/pressed-keys.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/pressed-keys/pressed-keys.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4a951677b47f115a09b5f4bb0074bd9d90aa3f97
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/pressed-keys/pressed-keys.svelte.d.ts
@@ -0,0 +1,20 @@
+import { type ConfigurableWindow } from "../../internal/configurable-globals.js";
+export type PressedKeysOptions = ConfigurableWindow;
+/**
+ * Tracks which keys are currently pressed.
+ *
+ * @see {@link https://runed.dev/docs/utilities/pressed-keys}
+ */
+export declare class PressedKeys {
+    #private;
+    constructor(options?: PressedKeysOptions);
+    has(...keys: string[]): boolean;
+    get all(): string[];
+    /**
+     * Registers a callback to execute when specified key combination is pressed.
+     *
+     * @param keys - Array or single string of keys to monitor
+     * @param callback - Function to execute when the key combination is matched
+     */
+    onKeys(keys: string | string[], callback: () => void): void;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/pressed-keys/pressed-keys.svelte.js b/tools/ui/node_modules/runed/dist/utilities/pressed-keys/pressed-keys.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0f36101c4eaab5403c3b00d08b6ab59adf8e19
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/pressed-keys/pressed-keys.svelte.js
@@ -0,0 +1,88 @@
+import { on } from "svelte/events";
+import { createSubscriber } from "svelte/reactivity";
+import { watch } from "../watch/index.js";
+import { defaultWindow } from "../../internal/configurable-globals.js";
+const modifierKeys = ["meta", "control", "alt", "shift"];
+/**
+ * Tracks which keys are currently pressed.
+ *
+ * @see {@link https://runed.dev/docs/utilities/pressed-keys}
+ */
+export class PressedKeys {
+    #pressedKeys = $state([]);
+    #subscribe;
+    constructor(options = {}) {
+        const { window = defaultWindow } = options;
+        this.has = this.has.bind(this);
+        if (!window)
+            return;
+        this.#subscribe = createSubscriber((update) => {
+            const keydown = on(window, "keydown", (e) => {
+                const key = e.key.toLowerCase();
+                if (!this.#pressedKeys.includes(key)) {
+                    this.#pressedKeys.push(key);
+                }
+                update();
+            });
+            const keyup = on(window, "keyup", (e) => {
+                const key = e.key.toLowerCase();
+                // Special handling for modifier keys (meta, control, alt, shift)
+                // This addresses issues with OS/browser intercepting certain key combinations
+                // where non-modifier keyup events might not fire properly
+                if (modifierKeys.includes(key)) {
+                    // When a modifier key is released, clear all non-modifier keys
+                    // but keep other modifier keys that might still be pressed
+                    // This prevents keys from getting "stuck" in the pressed state
+                    this.#pressedKeys = this.#pressedKeys.filter((k) => modifierKeys.includes(k));
+                }
+                // Regular key removal
+                this.#pressedKeys = this.#pressedKeys.filter((k) => k !== key);
+                update();
+            });
+            // Handle window blur events (switching applications, clicking outside browser)
+            // Reset all keys when user shifts focus away from the window
+            const blur = on(window, "blur", () => {
+                this.#pressedKeys = [];
+                update();
+            });
+            // Handle tab visibility changes (switching browser tabs)
+            // This catches cases where the window doesn't lose focus but the tab is hidden
+            const visibilityChange = on(document, "visibilitychange", () => {
+                if (document.visibilityState === "hidden") {
+                    this.#pressedKeys = [];
+                    update();
+                }
+            });
+            return () => {
+                keydown();
+                keyup();
+                blur();
+                visibilityChange();
+            };
+        });
+    }
+    has(...keys) {
+        this.#subscribe?.();
+        const normalizedKeys = keys.map((key) => key.toLowerCase());
+        return normalizedKeys.every((key) => this.#pressedKeys.includes(key));
+    }
+    get all() {
+        this.#subscribe?.();
+        return this.#pressedKeys;
+    }
+    /**
+     * Registers a callback to execute when specified key combination is pressed.
+     *
+     * @param keys - Array or single string of keys to monitor
+     * @param callback - Function to execute when the key combination is matched
+     */
+    onKeys(keys, callback) {
+        this.#subscribe?.();
+        const keysToMonitor = Array.isArray(keys) ? keys : [keys];
+        watch(() => this.all, () => {
+            if (this.has(...keysToMonitor)) {
+                callback();
+            }
+        });
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/previous/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/previous/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9c45eae4698060fb949ee0e56ccc6ea6a72f3603
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/previous/index.d.ts
@@ -0,0 +1 @@
+export * from "./previous.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/previous/index.js b/tools/ui/node_modules/runed/dist/utilities/previous/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..9c45eae4698060fb949ee0e56ccc6ea6a72f3603
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/previous/index.js
@@ -0,0 +1 @@
+export * from "./previous.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/previous/previous.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/previous/previous.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a1f71c10b278cd680b1a66404792aa123c73c7fa
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/previous/previous.svelte.d.ts
@@ -0,0 +1,11 @@
+import type { Getter } from "../../internal/types.js";
+/**
+ * Holds the previous value of a getter.
+ *
+ * @see {@link https://runed.dev/docs/utilities/previous}
+ */
+export declare class Previous {
+    #private;
+    constructor(getter: Getter, initialValue?: T);
+    get current(): T | undefined;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/previous/previous.svelte.js b/tools/ui/node_modules/runed/dist/utilities/previous/previous.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..e5c87b78e0a68dd3e4d4ef6c75f235e5c0968895
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/previous/previous.svelte.js
@@ -0,0 +1,25 @@
+/**
+ * Holds the previous value of a getter.
+ *
+ * @see {@link https://runed.dev/docs/utilities/previous}
+ */
+export class Previous {
+    #previousCallback = () => undefined;
+    #previous = $derived.by(() => this.#previousCallback());
+    constructor(getter, initialValue) {
+        let actualPrevious = undefined;
+        if (initialValue !== undefined)
+            actualPrevious = initialValue;
+        this.#previousCallback = () => {
+            try {
+                return actualPrevious;
+            }
+            finally {
+                actualPrevious = getter();
+            }
+        };
+    }
+    get current() {
+        return this.#previous;
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/resource/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/resource/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..78b847d046f4edd53bafb7c85f8deba71b4471be
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/resource/index.d.ts
@@ -0,0 +1 @@
+export * from "./resource.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/resource/index.js b/tools/ui/node_modules/runed/dist/utilities/resource/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..78b847d046f4edd53bafb7c85f8deba71b4471be
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/resource/index.js
@@ -0,0 +1 @@
+export * from "./resource.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/resource/msw-handlers.d.ts b/tools/ui/node_modules/runed/dist/utilities/resource/msw-handlers.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f55c8f8334a7767a6ac9046b28c4767e2032021a
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/resource/msw-handlers.d.ts
@@ -0,0 +1,14 @@
+export type ResponseData = {
+    id: number;
+    name: string;
+    email: string;
+};
+export type SearchResponseData = {
+    results: {
+        id: number;
+        title: string;
+    }[];
+    page: number;
+    total: number;
+};
+export declare const handlers: import("msw").HttpHandler[];
diff --git a/tools/ui/node_modules/runed/dist/utilities/resource/msw-handlers.js b/tools/ui/node_modules/runed/dist/utilities/resource/msw-handlers.js
new file mode 100644
index 0000000000000000000000000000000000000000..55c9a3e2e79e1a8c4d5854088c1b5ef3ecf7f497
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/resource/msw-handlers.js
@@ -0,0 +1,30 @@
+import { http, delay, HttpResponse } from "msw";
+export const handlers = [
+    // Basic user endpoint
+    http.get("https://api.example.com/users/:id", async ({ params }) => {
+        await delay(50);
+        return HttpResponse.json({
+            id: Number(params.id),
+            name: `User ${params.id}`,
+            email: `user${params.id}@example.com`,
+        });
+    }),
+    // Search endpoint with query params
+    http.get("https://api.example.com/search", ({ request }) => {
+        const url = new URL(request.url);
+        const query = url.searchParams.get("q");
+        const page = Number(url.searchParams.get("page")) || 1;
+        return HttpResponse.json({
+            results: [
+                { id: page * 1, title: `Result 1 for ${query}` },
+                { id: page * 2, title: `Result 2 for ${query}` },
+            ],
+            page,
+            total: 10,
+        });
+    }),
+    // Endpoint that can fail
+    http.get("https://api.example.com/error-prone", () => {
+        return new HttpResponse(null, { status: 500 });
+    }),
+];
diff --git a/tools/ui/node_modules/runed/dist/utilities/resource/resource.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/resource/resource.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..07a9414af2af0c7eb4cfb7f20b9564b18c3f8b30
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/resource/resource.svelte.d.ts
@@ -0,0 +1,147 @@
+import type { Getter } from "../../internal/types.js";
+/**
+ * Configuration options for the resource function
+ */
+export type ResourceOptions = {
+    /** Skip initial fetch when true */
+    lazy?: boolean;
+    /** Only fetch once when true */
+    once?: boolean;
+    /** Initial value for the resource */
+    initialValue?: Data;
+    /** Debounce time in milliseconds */
+    debounce?: number;
+    /** Throttle time in milliseconds */
+    throttle?: number;
+};
+/**
+ * Core state of a resource
+ */
+export type ResourceState = {
+    /** Current value of the resource */
+    current: HasInitialValue extends true ? Data : Data | undefined;
+    /** Whether the resource is currently loading */
+    loading: boolean;
+    /** Error if the fetch failed */
+    error: Error | undefined;
+};
+/**
+ * Return type of the resource function, extends ResourceState with additional methods
+ */
+export type ResourceReturn = ResourceState & {
+    /** Update the resource value directly */
+    mutate: (value: Data) => void;
+    /** Re-run the fetcher with current values */
+    refetch: (info?: RefetchInfo) => Promise;
+};
+export type ResourceFetcherRefetchInfo = {
+    /** Previous data return from fetcher */
+    data: Data | undefined;
+    /** Whether the fetcher is currently refetching or it can be the value you passed to refetch. */
+    refetching: RefetchInfo | boolean;
+    /** A cleanup function that will be called when the source is invalidated and the fetcher is about to re-run */
+    onCleanup: (fn: () => void) => void;
+    /** AbortSignal for cancelling fetch requests */
+    signal: AbortSignal;
+};
+export type ResourceFetcher = (
+/** Current value of the source */
+value: Source extends Array ? {
+    [K in keyof Source]: Source[K];
+} : Source, 
+/** Previous value of the source */
+previousValue: Source extends Array ? {
+    [K in keyof Source]: Source[K];
+} : Source | undefined, info: ResourceFetcherRefetchInfo) => Promise;
+/**
+ * Creates a reactive resource that combines reactive dependency tracking with async data fetching.
+ * This version uses watch under the hood and runs after render.
+ * For pre-render execution, use resource.pre().
+ *
+ * Features:
+ * - Automatic request cancellation when dependencies change
+ * - Built-in loading and error states
+ * - Support for initial values and lazy loading
+ * - Type-safe reactive dependencies
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with automatic request cancellation
+ * const userResource = resource(
+ *   () => userId,
+ *   async (newId, prevId, { signal }) => {
+ *     const res = await fetch(`/api/users/${newId}`, { signal });
+ *     return res.json();
+ *   }
+ * );
+ *
+ * // Multiple dependencies
+ * const searchResource = resource(
+ *   [() => query, () => page],
+ *   async ([query, page], [prevQuery, prevPage], { signal }) => {
+ *     const res = await fetch(
+ *       `/api/search?q=${query}&page=${page}`,
+ *       { signal }
+ *     );
+ *     return res.json();
+ *   },
+ *   { lazy: true }
+ * );
+ *
+ * // Custom cleanup with built-in request cancellation
+ * const streamResource = resource(
+ *   () => streamId,
+ *   async (id, prevId, { signal, onCleanup }) => {
+ *     const eventSource = new EventSource(`/api/stream/${id}`);
+ *     onCleanup(() => eventSource.close());
+ *
+ *     const res = await fetch(`/api/stream/${id}/init`, { signal });
+ *     return res.json();
+ *   }
+ * );
+ * ```
+ */
+export declare function resource>, RefetchInfo> = ResourceFetcher>(source: Getter, fetcher: Fetcher, options: ResourceOptions>> & {
+    initialValue: Awaited>;
+}): ResourceReturn>, RefetchInfo, true>;
+export declare function resource>, RefetchInfo> = ResourceFetcher>(source: Getter, fetcher: Fetcher, options?: Omit>>, "initialValue">): ResourceReturn>, RefetchInfo, false>;
+export declare function resource, RefetchInfo = unknown, Fetcher extends ResourceFetcher>, RefetchInfo> = ResourceFetcher>(sources: {
+    [K in keyof Sources]: Getter;
+}, fetcher: Fetcher, options: ResourceOptions>> & {
+    initialValue: Awaited>;
+}): ResourceReturn>, RefetchInfo, true>;
+export declare function resource, RefetchInfo = unknown, Fetcher extends ResourceFetcher>, RefetchInfo> = ResourceFetcher>(sources: {
+    [K in keyof Sources]: Getter;
+}, fetcher: Fetcher, options?: Omit>>, "initialValue">): ResourceReturn>, RefetchInfo, false>;
+export declare namespace resource {
+    var pre: typeof resourcePre;
+}
+/**
+ * Helper function to create a resource with pre-effect (runs before render).
+ * Uses watch.pre internally instead of watch for pre-render execution.
+ * Includes all features of the standard resource including automatic request cancellation.
+ *
+ * @example
+ * ```typescript
+ * // Pre-render resource with automatic cancellation
+ * const data = resource.pre(
+ *   () => query,
+ *   async (newQuery, prevQuery, { signal }) => {
+ *     const res = await fetch(`/api/search?q=${newQuery}`, { signal });
+ *     return res.json();
+ *   }
+ * );
+ * ```
+ */
+export declare function resourcePre>, RefetchInfo> = ResourceFetcher>(source: Getter, fetcher: Fetcher, options: ResourceOptions>> & {
+    initialValue: Awaited>;
+}): ResourceReturn>, RefetchInfo, true>;
+export declare function resourcePre>, RefetchInfo> = ResourceFetcher>(source: Getter, fetcher: Fetcher, options?: Omit>>, "initialValue">): ResourceReturn>, RefetchInfo, false>;
+export declare function resourcePre, RefetchInfo = unknown, Fetcher extends ResourceFetcher>, RefetchInfo> = ResourceFetcher>(sources: {
+    [K in keyof Sources]: Getter;
+}, fetcher: Fetcher, options: ResourceOptions>> & {
+    initialValue: Awaited>;
+}): ResourceReturn>, RefetchInfo, true>;
+export declare function resourcePre, RefetchInfo = unknown, Fetcher extends ResourceFetcher>, RefetchInfo> = ResourceFetcher>(sources: {
+    [K in keyof Sources]: Getter;
+}, fetcher: Fetcher, options?: Omit>>, "initialValue">): ResourceReturn>, RefetchInfo, false>;
diff --git a/tools/ui/node_modules/runed/dist/utilities/resource/resource.svelte.js b/tools/ui/node_modules/runed/dist/utilities/resource/resource.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..12897e5e7071f114d9f5909b41b1397dced116e3
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/resource/resource.svelte.js
@@ -0,0 +1,139 @@
+import { watch } from "../watch/index.js";
+// Helper functions for debounce and throttle
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function debounce(fn, delay) {
+    let timeoutId;
+    let lastResolve = null;
+    return (...args) => {
+        return new Promise((resolve) => {
+            if (lastResolve) {
+                lastResolve(undefined);
+            }
+            lastResolve = resolve;
+            clearTimeout(timeoutId);
+            timeoutId = setTimeout(async () => {
+                const result = await fn(...args);
+                if (lastResolve) {
+                    lastResolve(result);
+                    lastResolve = null;
+                }
+            }, delay);
+        });
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function throttle(fn, delay) {
+    let lastRun = 0;
+    let lastPromise = null;
+    return (...args) => {
+        const now = Date.now();
+        if (lastRun && now - lastRun < delay) {
+            return lastPromise ?? Promise.resolve(undefined);
+        }
+        lastRun = now;
+        lastPromise = fn(...args);
+        return lastPromise;
+    };
+}
+function runResource(source, fetcher, options = {}, effectFn) {
+    const { lazy = false, once = false, initialValue, debounce: debounceTime, throttle: throttleTime, } = options;
+    // Create state
+    let current = $state(initialValue);
+    let loading = $state(false);
+    let error = $state(undefined);
+    let cleanupFns = $state([]);
+    // Helper function to run cleanup functions
+    const runCleanup = () => {
+        cleanupFns.forEach((fn) => fn());
+        cleanupFns = [];
+    };
+    // Helper function to register cleanup
+    const onCleanup = (fn) => {
+        cleanupFns = [...cleanupFns, fn];
+    };
+    // Create the base fetcher function
+    const baseFetcher = async (value, previousValue, refetching = false) => {
+        try {
+            loading = true;
+            error = undefined;
+            runCleanup();
+            // Create new AbortController for this fetch
+            const controller = new AbortController();
+            onCleanup(() => controller.abort());
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = await fetcher(value, previousValue, {
+                data: current,
+                refetching,
+                onCleanup,
+                signal: controller.signal,
+            });
+            current = result;
+            return result;
+        }
+        catch (e) {
+            if (!(e instanceof DOMException && e.name === "AbortError")) {
+                error = e;
+            }
+            return undefined;
+        }
+        finally {
+            loading = false;
+        }
+    };
+    // Apply debounce or throttle if specified
+    const runFetcher = debounceTime
+        ? debounce(baseFetcher, debounceTime)
+        : throttleTime
+            ? throttle(baseFetcher, throttleTime)
+            : baseFetcher;
+    // Setup effect
+    const sources = Array.isArray(source) ? source : [source];
+    let prevValues;
+    effectFn((values, previousValues) => {
+        // Skip if once and already ran
+        if (once && prevValues) {
+            return;
+        }
+        prevValues = values;
+        runFetcher(Array.isArray(source) ? values : values[0], Array.isArray(source) ? previousValues : previousValues?.[0]);
+    }, { lazy });
+    return {
+        get current() {
+            return current;
+        },
+        get loading() {
+            return loading;
+        },
+        get error() {
+            return error;
+        },
+        mutate: (value) => {
+            current = value;
+        },
+        refetch: (info) => {
+            const values = sources.map((s) => s());
+            return runFetcher(Array.isArray(source) ? values : values[0], Array.isArray(source) ? values : values[0], info ?? true);
+        },
+    };
+}
+// Implementation
+export function resource(source, fetcher, options) {
+    return runResource(source, fetcher, options, (fn, options) => {
+        const sources = Array.isArray(source) ? source : [source];
+        const getters = () => sources.map((s) => s());
+        watch(getters, (values, previousValues) => {
+            fn(values, previousValues ?? []);
+        }, options);
+    });
+}
+// Implementation
+export function resourcePre(source, fetcher, options) {
+    return runResource(source, fetcher, options, (fn, options) => {
+        const sources = Array.isArray(source) ? source : [source];
+        const getter = () => sources.map((s) => s());
+        watch.pre(getter, (values, previousValues) => {
+            fn(values, previousValues ?? []);
+        }, options);
+    });
+}
+resource.pre = resourcePre;
diff --git a/tools/ui/node_modules/runed/dist/utilities/scroll-state/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/scroll-state/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e9fe1c62ef43065a254de9fa72ab6a58dde7d93b
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/scroll-state/index.d.ts
@@ -0,0 +1 @@
+export * from "./scroll-state.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/scroll-state/index.js b/tools/ui/node_modules/runed/dist/utilities/scroll-state/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..e9fe1c62ef43065a254de9fa72ab6a58dde7d93b
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/scroll-state/index.js
@@ -0,0 +1 @@
+export * from "./scroll-state.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/scroll-state/scroll-state.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/scroll-state/scroll-state.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fc0a6a6cd7c6accc9a65a88f4fe8974e3b6b216f
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/scroll-state/scroll-state.svelte.d.ts
@@ -0,0 +1,122 @@
+import type { MaybeGetter } from "../../internal/types.js";
+export interface ScrollStateOptions {
+    /**
+     * The scroll container.
+     *
+     * Can be an HTMLElement, Window, or Document, or a getter returning one of these.
+     */
+    element: MaybeGetter;
+    /**
+     * Debounce timeout (ms) after scrolling ends.
+     *
+     * @default 200
+     */
+    idle?: MaybeGetter;
+    /**
+     * Pixel offset thresholds for determining "arrived" state on each scroll edge.
+     */
+    offset?: MaybeGetter<{
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    } | undefined>;
+    /**
+     * Called during scroll events.
+     */
+    onScroll?: (e: Event) => void;
+    /**
+     * Called after scroll ends (after debounce).
+     */
+    onStop?: (e: Event) => void;
+    /**
+     * Scroll event listener options.
+     *
+     * @default { capture: false, passive: true }
+     */
+    eventListenerOptions?: AddEventListenerOptions;
+    /**
+     * Scroll behavior when using `scrollTo`, `scrollToTop`, or `scrollToBottom`,
+     *
+     * @default 'auto'
+     */
+    behavior?: MaybeGetter;
+    /**
+     * Optional error handler.
+     *
+     * @default console.error
+     */
+    onError?: (error: unknown) => void;
+}
+/**
+ * A reactive utility for tracking scroll position, direction,
+ * and edge arrival states, while supporting programmatic scrolling.
+ *
+ * @see https://vueuse.org/useScroll for the inspiration behind this utility.
+ * @param element
+ * @param options
+ */
+export declare class ScrollState {
+    #private;
+    element: Window | Document | HTMLElement | null | undefined;
+    idle: number;
+    offset: {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    };
+    onScroll: (e: Event) => void;
+    onStop: (e: Event) => void;
+    eventListenerOptions: AddEventListenerOptions;
+    behavior: "auto" | "instant" | "smooth";
+    onError: (error: unknown) => void;
+    /** State */
+    internalX: number;
+    internalY: number;
+    get x(): number;
+    set x(v: number);
+    get y(): number;
+    set y(v: number);
+    isScrolling: boolean;
+    arrived: {
+        left: boolean;
+        right: boolean;
+        top: boolean;
+        bottom: boolean;
+    };
+    directions: {
+        left: boolean;
+        right: boolean;
+        top: boolean;
+        bottom: boolean;
+    };
+    progress: {
+        x: number;
+        y: number;
+    };
+    constructor(options: ScrollStateOptions);
+    /**
+     * Updates direction and edge arrival states based on the current scroll position.
+     * Takes into account writing mode, flex direction, and RTL layouts.
+     */
+    setArrivedState: () => void;
+    /**
+     * Programmatically scroll to a specific position.
+     */
+    scrollTo(x: number | undefined, y: number | undefined): void;
+    /**
+     * Scrolls to the top of the element.
+     */
+    scrollToTop(): void;
+    /**
+     * Scrolls to the bottom of the element.
+     */
+    scrollToBottom(): void;
+    onScrollEnd: (e: Event) => void;
+    onScrollEndDebounced: ((this: unknown, e: Event) => Promise) & {
+        cancel: () => void;
+        runScheduledNow: () => Promise;
+        pending: boolean;
+    };
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/scroll-state/scroll-state.svelte.js b/tools/ui/node_modules/runed/dist/utilities/scroll-state/scroll-state.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..5a83575b74baca6e48acc46dc2d317b5680a5820
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/scroll-state/scroll-state.svelte.js
@@ -0,0 +1,206 @@
+import { AnimationFrames } from "../animation-frames/index.js";
+import { useDebounce } from "../use-debounce/index.js";
+import { useEventListener } from "../use-event-listener/index.js";
+import { onMount } from "svelte";
+import { extract } from "../extract/extract.svelte.js";
+import { noop } from "../../internal/utils/function.js";
+/**
+ * We have to check if the scroll amount is close enough to some threshold in order to
+ * more accurately calculate arrivedState. This is because scrollTop/scrollLeft are non-rounded
+ * numbers, while scrollHeight/scrollWidth and clientHeight/clientWidth are rounded.
+ * https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight#determine_if_an_element_has_been_totally_scrolled
+ */
+const ARRIVED_STATE_THRESHOLD_PIXELS = 1;
+/**
+ * A reactive utility for tracking scroll position, direction,
+ * and edge arrival states, while supporting programmatic scrolling.
+ *
+ * @see https://vueuse.org/useScroll for the inspiration behind this utility.
+ * @param element
+ * @param options
+ */
+export class ScrollState {
+    #options;
+    element = $derived(extract(this.#options.element));
+    idle = $derived.by(() => extract(this.#options?.idle, 200));
+    offset = $derived(extract(this.#options.offset, {
+        left: 0,
+        right: 0,
+        top: 0,
+        bottom: 0,
+    }));
+    onScroll = $derived(this.#options.onScroll ?? noop);
+    onStop = $derived(this.#options.onStop ?? noop);
+    eventListenerOptions = $derived(this.#options.eventListenerOptions ?? {
+        capture: false,
+        passive: true,
+    });
+    behavior = $derived(extract(this.#options.behavior, "auto"));
+    onError = $derived(this.#options.onError ??
+        ((e) => {
+            console.error(e);
+        }));
+    /** State */
+    internalX = $state(0);
+    internalY = $state(0);
+    // Use a get/set pair for x and y because we want to write the value to the refs
+    // during a `scrollTo()` without firing additional `scrollTo()`s in the process.
+    #x = $derived(this.internalX);
+    get x() {
+        return this.#x;
+    }
+    set x(v) {
+        this.scrollTo(v, undefined);
+    }
+    #y = $derived(this.internalY);
+    get y() {
+        return this.#y;
+    }
+    set y(v) {
+        this.scrollTo(undefined, v);
+    }
+    isScrolling = $state(false);
+    arrived = $state({
+        left: true,
+        right: false,
+        top: true,
+        bottom: false,
+    });
+    directions = $state({
+        left: false,
+        right: false,
+        top: false,
+        bottom: false,
+    });
+    progress = $state({
+        x: 0,
+        y: 0,
+    });
+    constructor(options) {
+        this.#options = options;
+        useEventListener(() => this.element, "scroll", this.#onScrollHandler, this.eventListenerOptions);
+        useEventListener(() => this.element, "scrollend", (e) => this.onScrollEnd(e), this.eventListenerOptions);
+        onMount(() => {
+            this.setArrivedState();
+        });
+        // overkill?
+        new AnimationFrames(() => this.setArrivedState());
+    }
+    /**
+     * Updates direction and edge arrival states based on the current scroll position.
+     * Takes into account writing mode, flex direction, and RTL layouts.
+     */
+    setArrivedState = () => {
+        if (!window || !this.element)
+            return;
+        const el = (this.element?.document?.documentElement ||
+            this.element?.documentElement ||
+            this.element);
+        const { display, flexDirection, direction } = getComputedStyle(el);
+        const directionMultiplier = direction === "rtl" ? -1 : 1;
+        const scrollLeft = el.scrollLeft;
+        if (scrollLeft !== this.internalX) {
+            this.directions.left = scrollLeft < this.internalX;
+            this.directions.right = scrollLeft > this.internalX;
+        }
+        const left = scrollLeft * directionMultiplier <= (this.offset.left || 0);
+        const right = scrollLeft * directionMultiplier + el.clientWidth >=
+            el.scrollWidth - (this.offset.right || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;
+        if (display === "flex" && flexDirection === "row-reverse") {
+            this.arrived.left = right;
+            this.arrived.right = left;
+        }
+        else {
+            this.arrived.left = left;
+            this.arrived.right = right;
+        }
+        this.internalX = scrollLeft;
+        let scrollTop = el.scrollTop;
+        // patch for mobile compatible
+        if (this.element === window.document && !scrollTop)
+            scrollTop = window.document.body.scrollTop;
+        if (scrollTop !== this.internalY) {
+            this.directions.top = scrollTop < this.internalY;
+            this.directions.bottom = scrollTop > this.internalY;
+        }
+        const top = scrollTop <= (this.offset.top || 0);
+        const bottom = scrollTop + el.clientHeight >=
+            el.scrollHeight - (this.offset.bottom || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;
+        /**
+         * reverse columns and rows behave exactly the other way around,
+         * bottom is treated as top and top is treated as the negative version of bottom
+         */
+        if (display === "flex" && flexDirection === "column-reverse") {
+            this.arrived.top = bottom;
+            this.arrived.bottom = top;
+        }
+        else {
+            this.arrived.top = top;
+            this.arrived.bottom = bottom;
+        }
+        const height = el.scrollHeight - (this.offset.bottom || 0);
+        this.progress.y = (scrollTop / (height - el.clientHeight)) * 100;
+        const width = el.scrollWidth - (this.offset.left || 0);
+        // Math.abs for rtl support
+        this.progress.x = Math.abs((scrollLeft / (width - el.clientWidth)) * 100);
+        this.internalY = scrollTop;
+    };
+    #onScrollHandler = (e) => {
+        if (!window)
+            return;
+        this.setArrivedState();
+        this.isScrolling = true;
+        this.onScrollEndDebounced(e);
+        this.onScroll(e);
+    };
+    /**
+     * Programmatically scroll to a specific position.
+     */
+    scrollTo(x, y) {
+        if (!window)
+            return;
+        (this.element instanceof Document ? window.document.body : this.element)?.scrollTo({
+            top: y ?? this.y,
+            left: x ?? this.x,
+            behavior: this.behavior,
+        });
+        const scrollContainer = this.element?.document?.documentElement ||
+            this.element?.documentElement ||
+            this.element;
+        if (x != null)
+            this.internalX = scrollContainer.scrollLeft;
+        if (y != null)
+            this.internalY = scrollContainer.scrollTop;
+    }
+    /**
+     * Scrolls to the top of the element.
+     */
+    scrollToTop() {
+        this.scrollTo(undefined, 0);
+    }
+    /**
+     * Scrolls to the bottom of the element.
+     */
+    scrollToBottom() {
+        if (!window)
+            return;
+        const scrollContainer = this.element?.document?.documentElement ||
+            this.element?.documentElement ||
+            this.element;
+        if (!scrollContainer)
+            return;
+        this.scrollTo(undefined, scrollContainer.scrollHeight);
+    }
+    onScrollEnd = (e) => {
+        // dedupe if support native scrollend event
+        if (!this.isScrolling)
+            return;
+        this.isScrolling = false;
+        this.directions.left = false;
+        this.directions.right = false;
+        this.directions.top = false;
+        this.directions.bottom = false;
+        this.onStop(e);
+    };
+    onScrollEndDebounced = useDebounce(this.onScrollEnd, () => this.idle);
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/state-history/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/state-history/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a0c4565df2f2a7394e4f4d405d57cd1f7dde9020
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/state-history/index.d.ts
@@ -0,0 +1 @@
+export * from "./state-history.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/state-history/index.js b/tools/ui/node_modules/runed/dist/utilities/state-history/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..a0c4565df2f2a7394e4f4d405d57cd1f7dde9020
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/state-history/index.js
@@ -0,0 +1 @@
+export * from "./state-history.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/state-history/state-history.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/state-history/state-history.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d838dcf456f703ec2f5034bab86ede3860ea63cb
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/state-history/state-history.svelte.d.ts
@@ -0,0 +1,24 @@
+import type { MaybeGetter, Setter } from "../../internal/types.js";
+type LogEvent = {
+    snapshot: T;
+    timestamp: number;
+};
+type StateHistoryOptions = {
+    capacity?: MaybeGetter;
+};
+/**
+ * Tracks the change history of a value, providing undo and redo capabilities.
+ *
+ * @see {@link https://runed.dev/docs/utilities/state-history}
+ */
+export declare class StateHistory {
+    #private;
+    log: LogEvent[];
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    constructor(value: MaybeGetter, set: Setter, options?: StateHistoryOptions);
+    undo(): void;
+    redo(): void;
+    clear(): void;
+}
+export {};
diff --git a/tools/ui/node_modules/runed/dist/utilities/state-history/state-history.svelte.js b/tools/ui/node_modules/runed/dist/utilities/state-history/state-history.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..724c8aa9795e6ef4a69674cc895c10e7be4c984c
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/state-history/state-history.svelte.js
@@ -0,0 +1,62 @@
+import { watch } from "../watch/watch.svelte.js";
+import { get } from "../../internal/utils/get.js";
+/**
+ * Tracks the change history of a value, providing undo and redo capabilities.
+ *
+ * @see {@link https://runed.dev/docs/utilities/state-history}
+ */
+export class StateHistory {
+    #redoStack = $state([]);
+    #ignoreUpdate = false;
+    #set;
+    log = $state([]);
+    canUndo = $derived(this.log.length > 1);
+    canRedo = $derived(this.#redoStack.length > 0);
+    constructor(value, set, options) {
+        this.#redoStack = [];
+        this.#set = set;
+        this.undo = this.undo.bind(this);
+        this.redo = this.redo.bind(this);
+        const addEvent = (event) => {
+            this.log.push(event);
+            const capacity$ = get(options?.capacity);
+            if (capacity$ && this.log.length > capacity$) {
+                this.log = this.log.slice(-capacity$);
+            }
+        };
+        watch(() => get(value), (v) => {
+            if (this.#ignoreUpdate) {
+                this.#ignoreUpdate = false;
+                return;
+            }
+            addEvent({ snapshot: v, timestamp: new Date().getTime() });
+            this.#redoStack = [];
+        });
+        watch(() => get(options?.capacity), (c) => {
+            if (!c)
+                return;
+            this.log = this.log.slice(-c);
+        });
+    }
+    undo() {
+        const [prev, curr] = this.log.slice(-2);
+        if (!curr || !prev)
+            return;
+        this.#ignoreUpdate = true;
+        this.#redoStack.push(curr);
+        this.log.pop();
+        this.#set(prev.snapshot);
+    }
+    redo() {
+        const nextEvent = this.#redoStack.pop();
+        if (!nextEvent)
+            return;
+        this.#ignoreUpdate = true;
+        this.log.push(nextEvent);
+        this.#set(nextEvent.snapshot);
+    }
+    clear() {
+        this.log = [];
+        this.#redoStack = [];
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/textarea-autosize/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/textarea-autosize/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..94518eac418604d8b32a40ff8d5a4821d4e1c500
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/textarea-autosize/index.d.ts
@@ -0,0 +1 @@
+export * from "./textarea-autosize.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/textarea-autosize/index.js b/tools/ui/node_modules/runed/dist/utilities/textarea-autosize/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..94518eac418604d8b32a40ff8d5a4821d4e1c500
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/textarea-autosize/index.js
@@ -0,0 +1 @@
+export * from "./textarea-autosize.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/textarea-autosize/textarea-autosize.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/textarea-autosize/textarea-autosize.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3174ba365aea744386cb9e76e4dad70054dd1bab
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/textarea-autosize/textarea-autosize.svelte.d.ts
@@ -0,0 +1,51 @@
+import type { Getter, MaybeGetter } from "../../internal/types.js";
+export interface TextareaAutosizeOptions {
+    /**
+     * The textarea element to autosize.
+     */
+    element: MaybeGetter;
+    /**
+     * The current text value of the textarea.
+     * Should be reactive.
+     */
+    input: Getter;
+    /**
+     * Callback triggered whenever the textarea resizes.
+     */
+    onResize?: () => void;
+    /**
+     * Style property to update during resize. Defaults to `"height"`.
+     * Use `"minHeight"` to allow natural expansion without shrinking.
+     *
+     * @default "height"
+     */
+    styleProp?: "height" | "minHeight";
+    /**
+     * Optional maximum height in pixels. If exceeded, scrolling is enabled.
+     *
+     * @default undefined (no limit)
+     */
+    maxHeight?: number;
+}
+/**
+ * Automatically resizes a textarea element based on its content and width.
+ *
+ * Uses a hidden clone for accurate measurements without layout shift.
+ * Reactively updates when the input or element changes, or when the
+ * element is resized.
+ */
+export declare class TextareaAutosize {
+    #private;
+    element: HTMLElement | undefined;
+    input: string;
+    styleProp: "height" | "minHeight";
+    maxHeight: number | undefined;
+    textareaHeight: number;
+    textareaOldWidth: number;
+    constructor(options: TextareaAutosizeOptions);
+    /**
+     * Recomputes the required height based on current content and applies it
+     * to the textarea. If `maxHeight` is exceeded, vertical scrolling is enabled.
+     */
+    triggerResize: () => void;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/textarea-autosize/textarea-autosize.svelte.js b/tools/ui/node_modules/runed/dist/utilities/textarea-autosize/textarea-autosize.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..ec38da3abae806d2a54fc9d84f84ca86deddd45b
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/textarea-autosize/textarea-autosize.svelte.js
@@ -0,0 +1,131 @@
+import { useResizeObserver } from "../use-resize-observer/index.js";
+import { watch } from "../watch/index.js";
+import { tick } from "svelte";
+import { extract } from "../extract/index.js";
+const stylesToCopy = [
+    "box-sizing",
+    "width",
+    "padding-top",
+    "padding-right",
+    "padding-bottom",
+    "padding-left",
+    "border-top-width",
+    "border-right-width",
+    "border-bottom-width",
+    "border-left-width",
+    "font-family",
+    "font-size",
+    "font-weight",
+    "font-style",
+    "letter-spacing",
+    "text-indent",
+    "text-transform",
+    "line-height",
+    "word-spacing",
+    "word-wrap",
+    "word-break",
+    "white-space",
+];
+/**
+ * Automatically resizes a textarea element based on its content and width.
+ *
+ * Uses a hidden clone for accurate measurements without layout shift.
+ * Reactively updates when the input or element changes, or when the
+ * element is resized.
+ */
+export class TextareaAutosize {
+    #options;
+    #resizeTimeout = null;
+    #hiddenTextarea = null;
+    element = $derived.by(() => extract(this.#options.element));
+    input = $derived.by(() => extract(this.#options.input));
+    styleProp = $derived.by(() => extract(this.#options.styleProp, "height"));
+    maxHeight = $derived.by(() => extract(this.#options.maxHeight, undefined));
+    textareaHeight = $state(0);
+    textareaOldWidth = $state(0);
+    constructor(options) {
+        this.#options = options;
+        // Create hidden textarea for measurements
+        this.#createHiddenTextarea();
+        watch([() => this.input, () => this.element], () => {
+            tick().then(() => this.triggerResize());
+        });
+        watch(() => this.textareaHeight, () => options?.onResize?.());
+        useResizeObserver(() => this.element, ([entry]) => {
+            if (!entry)
+                return;
+            const { contentRect } = entry;
+            if (this.textareaOldWidth === contentRect.width)
+                return;
+            this.textareaOldWidth = contentRect.width;
+            this.triggerResize();
+        });
+        $effect(() => {
+            return () => {
+                // Clean up
+                if (this.#hiddenTextarea) {
+                    this.#hiddenTextarea.remove();
+                    this.#hiddenTextarea = null;
+                }
+                if (this.#resizeTimeout) {
+                    window.cancelAnimationFrame(this.#resizeTimeout);
+                    this.#resizeTimeout = null;
+                }
+            };
+        });
+    }
+    // Copy all the styles that affect text layout
+    #createHiddenTextarea() {
+        // Create a hidden textarea that will be used for measurements
+        // This avoids layout shifts caused by manipulating the actual textarea
+        if (typeof window === "undefined")
+            return;
+        this.#hiddenTextarea = document.createElement("textarea");
+        const style = this.#hiddenTextarea.style;
+        // Make it invisible but keep same text layout properties
+        style.visibility = "hidden";
+        style.position = "absolute";
+        style.overflow = "hidden";
+        style.height = "0";
+        style.top = "0";
+        style.left = "-9999px";
+        document.body.appendChild(this.#hiddenTextarea);
+    }
+    #copyStyles() {
+        if (!this.element || !this.#hiddenTextarea)
+            return;
+        const computed = window.getComputedStyle(this.element);
+        for (const style of stylesToCopy) {
+            this.#hiddenTextarea.style.setProperty(style, computed.getPropertyValue(style));
+        }
+        // Ensure the width matches exactly
+        this.#hiddenTextarea.style.width = `${this.element.clientWidth}px`;
+    }
+    /**
+     * Recomputes the required height based on current content and applies it
+     * to the textarea. If `maxHeight` is exceeded, vertical scrolling is enabled.
+     */
+    triggerResize = () => {
+        if (!this.element || !this.#hiddenTextarea)
+            return;
+        // Copy current styles and content to hidden textarea
+        this.#copyStyles();
+        this.#hiddenTextarea.value = this.input || "";
+        // Measure the hidden textarea
+        const scrollHeight = this.#hiddenTextarea.scrollHeight;
+        // Apply the height, respecting maxHeight if set
+        let newHeight = scrollHeight;
+        if (this.maxHeight && newHeight > this.maxHeight) {
+            newHeight = this.maxHeight;
+            this.element.style.overflowY = "auto";
+        }
+        else {
+            this.element.style.overflowY = "hidden";
+        }
+        // Only update if height actually changed
+        if (this.textareaHeight !== newHeight) {
+            this.textareaHeight = newHeight;
+            this.element.style[this.styleProp] = `${newHeight}px`;
+        }
+    };
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/throttled/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/throttled/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a484d33408153778d823f5a4beffb4168d1d22d1
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/throttled/index.d.ts
@@ -0,0 +1 @@
+export * from "./throttled.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/throttled/index.js b/tools/ui/node_modules/runed/dist/utilities/throttled/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..a484d33408153778d823f5a4beffb4168d1d22d1
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/throttled/index.js
@@ -0,0 +1 @@
+export * from "./throttled.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/throttled/throttled.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/throttled/throttled.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3accec87a499f472281f09d6e81317444b44697b
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/throttled/throttled.svelte.d.ts
@@ -0,0 +1,8 @@
+import type { Getter, MaybeGetter } from "../../internal/types.js";
+export declare class Throttled {
+    #private;
+    constructor(getter: Getter, wait?: MaybeGetter);
+    get current(): T;
+    cancel(): void;
+    setImmediately(v: T): void;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/throttled/throttled.svelte.js b/tools/ui/node_modules/runed/dist/utilities/throttled/throttled.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..d93ae7c8f981dee1086925dc73ac5c65a35ab0ae
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/throttled/throttled.svelte.js
@@ -0,0 +1,26 @@
+import { useThrottle } from "../use-throttle/use-throttle.svelte.js";
+import { watch } from "../watch/watch.svelte.js";
+import { noop } from "../../internal/utils/function.js";
+export class Throttled {
+    #current = $state();
+    #throttleFn;
+    constructor(getter, wait = 250) {
+        this.#current = getter(); // Immediately set the initial value
+        this.#throttleFn = useThrottle(() => {
+            this.#current = getter();
+        }, wait);
+        watch(getter, () => {
+            this.#throttleFn()?.catch(noop);
+        });
+    }
+    get current() {
+        return this.#current;
+    }
+    cancel() {
+        this.#throttleFn.cancel();
+    }
+    setImmediately(v) {
+        this.cancel();
+        this.#current = v;
+    }
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/use-debounce/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/use-debounce/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1b167be0bb339c67a97696ea8f29ffb16b0cf98a
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/use-debounce/index.d.ts
@@ -0,0 +1 @@
+export * from "./use-debounce.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/use-debounce/index.js b/tools/ui/node_modules/runed/dist/utilities/use-debounce/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..1b167be0bb339c67a97696ea8f29ffb16b0cf98a
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/use-debounce/index.js
@@ -0,0 +1 @@
+export * from "./use-debounce.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/use-debounce/use-debounce.svelte.d.ts b/tools/ui/node_modules/runed/dist/utilities/use-debounce/use-debounce.svelte.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..570e0c9c35012378a6753e978095ff4841fd32f1
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/use-debounce/use-debounce.svelte.d.ts
@@ -0,0 +1,25 @@
+import type { MaybeGetter } from "../../internal/types.js";
+type UseDebounceReturn = ((this: unknown, ...args: Args) => Promise) & {
+    cancel: () => void;
+    runScheduledNow: () => Promise;
+    pending: boolean;
+};
+/**
+ * Function that takes a callback, and returns a debounced version of it.
+ * When calling the debounced function, it will wait for the specified time
+ * before calling the original callback. If the debounced function is called
+ * again before the time has passed, the timer will be reset.
+ *
+ * You can await the debounced function to get the value when it is eventually
+ * called.
+ *
+ * The second parameter is the time to wait before calling the original callback.
+ * Alternatively, it can also be a getter function that returns the time to wait.
+ *
+ * @see {@link https://runed.dev/docs/utilities/use-debounce}
+ *
+ * @param callback The callback to call when the time has passed.
+ * @param wait The length of time to wait in ms, defaults to 250.
+ */
+export declare function useDebounce(callback: (...args: Args) => Return, wait?: MaybeGetter): UseDebounceReturn;
+export {};
diff --git a/tools/ui/node_modules/runed/dist/utilities/use-debounce/use-debounce.svelte.js b/tools/ui/node_modules/runed/dist/utilities/use-debounce/use-debounce.svelte.js
new file mode 100644
index 0000000000000000000000000000000000000000..c99d880d74761cf2e15936c3bb9ab7e13fff32af
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/use-debounce/use-debounce.svelte.js
@@ -0,0 +1,92 @@
+import { extract } from "../extract/extract.svelte.js";
+/**
+ * Function that takes a callback, and returns a debounced version of it.
+ * When calling the debounced function, it will wait for the specified time
+ * before calling the original callback. If the debounced function is called
+ * again before the time has passed, the timer will be reset.
+ *
+ * You can await the debounced function to get the value when it is eventually
+ * called.
+ *
+ * The second parameter is the time to wait before calling the original callback.
+ * Alternatively, it can also be a getter function that returns the time to wait.
+ *
+ * @see {@link https://runed.dev/docs/utilities/use-debounce}
+ *
+ * @param callback The callback to call when the time has passed.
+ * @param wait The length of time to wait in ms, defaults to 250.
+ */
+export function useDebounce(callback, wait) {
+    let context = $state(null);
+    const wait$ = $derived(extract(wait, 250));
+    function debounced(...args) {
+        if (context) {
+            // Old context will be reused so callers awaiting the promise will get the
+            // new value
+            if (context.timeout) {
+                clearTimeout(context.timeout);
+            }
+        }
+        else {
+            // No old context, create a new one
+            let resolve;
+            let reject;
+            const promise = new Promise((res, rej) => {
+                resolve = res;
+                reject = rej;
+            });
+            context = {
+                timeout: null,
+                runner: null,
+                promise,
+                resolve: resolve,
+                reject: reject,
+            };
+        }
+        context.runner = async () => {
+            // Grab the context and reset it
+            // -> new debounced calls will create a new context
+            if (!context)
+                return;
+            const ctx = context;
+            context = null;
+            try {
+                ctx.resolve(await callback.apply(this, args));
+            }
+            catch (error) {
+                ctx.reject(error);
+            }
+        };
+        context.timeout = setTimeout(context.runner, wait$);
+        return context.promise;
+    }
+    debounced.cancel = async () => {
+        if (!context || context.timeout === null) {
+            // Wait one event loop to see if something triggered the debounced function
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            if (!context || context.timeout === null)
+                return;
+        }
+        clearTimeout(context.timeout);
+        context.reject("Cancelled");
+        context = null;
+    };
+    debounced.runScheduledNow = async () => {
+        if (!context || !context.timeout) {
+            // Wait one event loop to see if something triggered the debounced function
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            if (!context || !context.timeout)
+                return;
+        }
+        clearTimeout(context.timeout);
+        context.timeout = null;
+        await context.runner?.();
+    };
+    Object.defineProperty(debounced, "pending", {
+        enumerable: true,
+        get() {
+            return !!context?.timeout;
+        },
+    });
+    return debounced;
+}
diff --git a/tools/ui/node_modules/runed/dist/utilities/use-event-listener/index.d.ts b/tools/ui/node_modules/runed/dist/utilities/use-event-listener/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4e5c0750c18a6e474dc17b914744f8171656f789
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/use-event-listener/index.d.ts
@@ -0,0 +1 @@
+export * from "./use-event-listener.svelte.js";
diff --git a/tools/ui/node_modules/runed/dist/utilities/use-event-listener/index.js b/tools/ui/node_modules/runed/dist/utilities/use-event-listener/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e5c0750c18a6e474dc17b914744f8171656f789
--- /dev/null
+++ b/tools/ui/node_modules/runed/dist/utilities/use-event-listener/index.js
@@ -0,0 +1 @@
+export * from "./use-event-listener.svelte.js";