proskomma-core
Version:
A Scripture Runtime Engine
1,282 lines • 1.92 MB
JavaScript
"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
/*!
* XRegExp 5.1.1
* <xregexp.com>
* Steven Levithan (c) 2007-present MIT License
*/
const REGEX_DATA = "xregexp";
const features = {
astral: false,
namespacing: true
};
const fixed = {};
let regexCache = {};
let patternCache = {};
const tokens = [];
const defaultScope = "default";
const classScope = "class";
const nativeTokens = {
// Any native multicharacter token in default scope, or any single character
"default": /\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9]\d*|x[\dA-Fa-f]{2}|u(?:[\dA-Fa-f]{4}|{[\dA-Fa-f]+})|c[A-Za-z]|[\s\S])|\(\?(?:[:=!]|<[=!])|[?*+]\?|{\d+(?:,\d*)?}\??|[\s\S]/,
// Any native multicharacter token in character class scope, or any single character
"class": /\\(?:[0-3][0-7]{0,2}|[4-7][0-7]?|x[\dA-Fa-f]{2}|u(?:[\dA-Fa-f]{4}|{[\dA-Fa-f]+})|c[A-Za-z]|[\s\S])|[\s\S]/
};
const replacementToken = /\$(?:\{([^\}]+)\}|<([^>]+)>|(\d\d?|[\s\S]?))/g;
const correctExecNpcg = /()??/.exec("")[1] === void 0;
const hasFlagsProp = /x/.flags !== void 0;
function hasNativeFlag(flag) {
let isSupported = true;
try {
new RegExp("", flag);
if (flag === "y") {
const gy = (() => "gy")();
const incompleteY = ".a".replace(new RegExp("a", gy), ".") === "..";
if (incompleteY) {
isSupported = false;
}
}
} catch (exception) {
isSupported = false;
}
return isSupported;
}
const hasNativeD = hasNativeFlag("d");
const hasNativeS = hasNativeFlag("s");
const hasNativeU = hasNativeFlag("u");
const hasNativeY = hasNativeFlag("y");
const registeredFlags = {
d: hasNativeD,
g: true,
i: true,
m: true,
s: hasNativeS,
u: hasNativeU,
y: hasNativeY
};
const nonnativeFlags = hasNativeS ? /[^dgimsuy]+/g : /[^dgimuy]+/g;
function augment(regex, captureNames, xSource, xFlags, isInternalOnly) {
regex[REGEX_DATA] = {
captureNames
};
if (isInternalOnly) {
return regex;
}
if (regex.__proto__) {
regex.__proto__ = XRegExp.prototype;
} else {
for (const p in XRegExp.prototype) {
regex[p] = XRegExp.prototype[p];
}
}
regex[REGEX_DATA].source = xSource;
regex[REGEX_DATA].flags = xFlags ? xFlags.split("").sort().join("") : xFlags;
return regex;
}
function clipDuplicates(str) {
return str.replace(/([\s\S])(?=[\s\S]*\1)/g, "");
}
function copyRegex(regex, options2) {
if (!XRegExp.isRegExp(regex)) {
throw new TypeError("Type RegExp expected");
}
const xData = regex[REGEX_DATA] || {};
let flags = getNativeFlags(regex);
let flagsToAdd = "";
let flagsToRemove = "";
let xregexpSource = null;
let xregexpFlags = null;
options2 = options2 || {};
if (options2.removeG) {
flagsToRemove += "g";
}
if (options2.removeY) {
flagsToRemove += "y";
}
if (flagsToRemove) {
flags = flags.replace(new RegExp(`[${flagsToRemove}]+`, "g"), "");
}
if (options2.addG) {
flagsToAdd += "g";
}
if (options2.addY) {
flagsToAdd += "y";
}
if (flagsToAdd) {
flags = clipDuplicates(flags + flagsToAdd);
}
if (!options2.isInternalOnly) {
if (xData.source !== void 0) {
xregexpSource = xData.source;
}
if (xData.flags != null) {
xregexpFlags = flagsToAdd ? clipDuplicates(xData.flags + flagsToAdd) : xData.flags;
}
}
regex = augment(
new RegExp(options2.source || regex.source, flags),
hasNamedCapture(regex) ? xData.captureNames.slice(0) : null,
xregexpSource,
xregexpFlags,
options2.isInternalOnly
);
return regex;
}
function dec(hex2) {
return parseInt(hex2, 16);
}
function getContextualTokenSeparator(match, scope2, flags) {
const matchEndPos = match.index + match[0].length;
const precedingChar = match.input[match.index - 1];
const followingChar = match.input[matchEndPos];
if (
// No need to separate tokens if at the beginning or end of a group, before or after a
// group, or before or after a `|`
/^[()|]$/.test(precedingChar) || /^[()|]$/.test(followingChar) || // No need to separate tokens if at the beginning or end of the pattern
match.index === 0 || matchEndPos === match.input.length || // No need to separate tokens if at the beginning of a noncapturing group or lookaround.
// Looks only at the last 4 chars (at most) for perf when constructing long regexes.
/\(\?(?:[:=!]|<[=!])$/.test(match.input.substring(match.index - 4, match.index)) || // Avoid separating tokens when the following token is a quantifier
isQuantifierNext(match.input, matchEndPos, flags)
) {
return "";
}
return "(?:)";
}
function getNativeFlags(regex) {
return hasFlagsProp ? regex.flags : (
// Explicitly using `RegExp.prototype.toString` (rather than e.g. `String` or concatenation
// with an empty string) allows this to continue working predictably when
// `XRegExp.proptotype.toString` is overridden
/\/([a-z]*)$/i.exec(RegExp.prototype.toString.call(regex))[1]
);
}
function hasNamedCapture(regex) {
return !!(regex[REGEX_DATA] && regex[REGEX_DATA].captureNames);
}
function hex(dec2) {
return parseInt(dec2, 10).toString(16);
}
function isQuantifierNext(pattern2, pos, flags) {
const inlineCommentPattern = "\\(\\?#[^)]*\\)";
const lineCommentPattern = "#[^#\\n]*";
const quantifierPattern = "[?*+]|{\\d+(?:,\\d*)?}";
const regex = flags.includes("x") ? (
// Ignore any leading whitespace, line comments, and inline comments
new RegExp(`^(?:\\s|${lineCommentPattern}|${inlineCommentPattern})*(?:${quantifierPattern})`)
) : (
// Ignore any leading inline comments
new RegExp(`^(?:${inlineCommentPattern})*(?:${quantifierPattern})`)
);
return regex.test(pattern2.slice(pos));
}
function isType$1(value, type2) {
return Object.prototype.toString.call(value) === `[object ${type2}]`;
}
function nullThrows(value) {
if (value == null) {
throw new TypeError("Cannot convert null or undefined to object");
}
return value;
}
function pad4(str) {
while (str.length < 4) {
str = `0${str}`;
}
return str;
}
function prepareFlags(pattern2, flags) {
if (clipDuplicates(flags) !== flags) {
throw new SyntaxError(`Invalid duplicate regex flag ${flags}`);
}
pattern2 = pattern2.replace(/^\(\?([\w$]+)\)/, ($0, $1) => {
if (/[dgy]/.test($1)) {
throw new SyntaxError(`Cannot use flags dgy in mode modifier ${$0}`);
}
flags = clipDuplicates(flags + $1);
return "";
});
for (const flag of flags) {
if (!registeredFlags[flag]) {
throw new SyntaxError(`Unknown regex flag ${flag}`);
}
}
return {
pattern: pattern2,
flags
};
}
function prepareOptions(value) {
const options2 = {};
if (isType$1(value, "String")) {
XRegExp.forEach(value, /[^\s,]+/, (match) => {
options2[match] = true;
});
return options2;
}
return value;
}
function registerFlag(flag) {
if (!/^[\w$]$/.test(flag)) {
throw new Error("Flag must be a single character A-Za-z0-9_$");
}
registeredFlags[flag] = true;
}
function runTokens(pattern2, flags, pos, scope2, context) {
let i = tokens.length;
const leadChar = pattern2[pos];
let result = null;
let match;
let t;
while (i--) {
t = tokens[i];
if (t.leadChar && t.leadChar !== leadChar || t.scope !== scope2 && t.scope !== "all" || t.flag && !flags.includes(t.flag)) {
continue;
}
match = XRegExp.exec(pattern2, t.regex, pos, "sticky");
if (match) {
result = {
matchLength: match[0].length,
output: t.handler.call(context, match, scope2, flags),
reparse: t.reparse
};
break;
}
}
return result;
}
function setAstral(on) {
features.astral = on;
}
function setNamespacing(on) {
features.namespacing = on;
}
function XRegExp(pattern2, flags) {
if (XRegExp.isRegExp(pattern2)) {
if (flags !== void 0) {
throw new TypeError("Cannot supply flags when copying a RegExp");
}
return copyRegex(pattern2);
}
pattern2 = pattern2 === void 0 ? "" : String(pattern2);
flags = flags === void 0 ? "" : String(flags);
if (XRegExp.isInstalled("astral") && !flags.includes("A")) {
flags += "A";
}
if (!patternCache[pattern2]) {
patternCache[pattern2] = {};
}
if (!patternCache[pattern2][flags]) {
const context = {
hasNamedCapture: false,
captureNames: []
};
let scope2 = defaultScope;
let output = "";
let pos = 0;
let result;
const applied = prepareFlags(pattern2, flags);
let appliedPattern = applied.pattern;
const appliedFlags = applied.flags;
while (pos < appliedPattern.length) {
do {
result = runTokens(appliedPattern, appliedFlags, pos, scope2, context);
if (result && result.reparse) {
appliedPattern = appliedPattern.slice(0, pos) + result.output + appliedPattern.slice(pos + result.matchLength);
}
} while (result && result.reparse);
if (result) {
output += result.output;
pos += result.matchLength || 1;
} else {
const [token] = XRegExp.exec(appliedPattern, nativeTokens[scope2], pos, "sticky");
output += token;
pos += token.length;
if (token === "[" && scope2 === defaultScope) {
scope2 = classScope;
} else if (token === "]" && scope2 === classScope) {
scope2 = defaultScope;
}
}
}
patternCache[pattern2][flags] = {
// Use basic cleanup to collapse repeated empty groups like `(?:)(?:)` to `(?:)`. Empty
// groups are sometimes inserted during regex transpilation in order to keep tokens
// separated. However, more than one empty group in a row is never needed.
pattern: output.replace(/(?:\(\?:\))+/g, "(?:)"),
// Strip all but native flags
flags: appliedFlags.replace(nonnativeFlags, ""),
// `context.captureNames` has an item for each capturing group, even if unnamed
captures: context.hasNamedCapture ? context.captureNames : null
};
}
const generated = patternCache[pattern2][flags];
return augment(
new RegExp(generated.pattern, generated.flags),
generated.captures,
pattern2,
flags
);
}
XRegExp.prototype = new RegExp();
XRegExp.version = "5.1.1";
XRegExp._clipDuplicates = clipDuplicates;
XRegExp._hasNativeFlag = hasNativeFlag;
XRegExp._dec = dec;
XRegExp._hex = hex;
XRegExp._pad4 = pad4;
XRegExp.addToken = (regex, handler, options2) => {
options2 = options2 || {};
let { optionalFlags } = options2;
if (options2.flag) {
registerFlag(options2.flag);
}
if (optionalFlags) {
optionalFlags = optionalFlags.split("");
for (const flag of optionalFlags) {
registerFlag(flag);
}
}
tokens.push({
regex: copyRegex(regex, {
addG: true,
addY: hasNativeY,
isInternalOnly: true
}),
handler,
scope: options2.scope || defaultScope,
flag: options2.flag,
reparse: options2.reparse,
leadChar: options2.leadChar
});
XRegExp.cache.flush("patterns");
};
XRegExp.cache = (pattern2, flags) => {
if (!regexCache[pattern2]) {
regexCache[pattern2] = {};
}
return regexCache[pattern2][flags] || (regexCache[pattern2][flags] = XRegExp(pattern2, flags));
};
XRegExp.cache.flush = (cacheName) => {
if (cacheName === "patterns") {
patternCache = {};
} else {
regexCache = {};
}
};
XRegExp.escape = (str) => String(nullThrows(str)).replace(/[\\\[\]{}()*+?.^$|]/g, "\\$&").replace(/[\s#\-,]/g, (match) => `\\u${pad4(hex(match.charCodeAt(0)))}`);
XRegExp.exec = (str, regex, pos, sticky) => {
let cacheKey = "g";
let addY = false;
let fakeY = false;
let match;
addY = hasNativeY && !!(sticky || regex.sticky && sticky !== false);
if (addY) {
cacheKey += "y";
} else if (sticky) {
fakeY = true;
cacheKey += "FakeY";
}
regex[REGEX_DATA] = regex[REGEX_DATA] || {};
const r2 = regex[REGEX_DATA][cacheKey] || (regex[REGEX_DATA][cacheKey] = copyRegex(regex, {
addG: true,
addY,
source: fakeY ? `${regex.source}|()` : void 0,
removeY: sticky === false,
isInternalOnly: true
}));
pos = pos || 0;
r2.lastIndex = pos;
match = fixed.exec.call(r2, str);
if (fakeY && match && match.pop() === "") {
match = null;
}
if (regex.global) {
regex.lastIndex = match ? r2.lastIndex : 0;
}
return match;
};
XRegExp.forEach = (str, regex, callback) => {
let pos = 0;
let i = -1;
let match;
while (match = XRegExp.exec(str, regex, pos)) {
callback(match, ++i, str, regex);
pos = match.index + (match[0].length || 1);
}
};
XRegExp.globalize = (regex) => copyRegex(regex, { addG: true });
XRegExp.install = (options2) => {
options2 = prepareOptions(options2);
if (!features.astral && options2.astral) {
setAstral(true);
}
if (!features.namespacing && options2.namespacing) {
setNamespacing(true);
}
};
XRegExp.isInstalled = (feature) => !!features[feature];
XRegExp.isRegExp = (value) => Object.prototype.toString.call(value) === "[object RegExp]";
XRegExp.match = (str, regex, scope2) => {
const global2 = regex.global && scope2 !== "one" || scope2 === "all";
const cacheKey = (global2 ? "g" : "") + (regex.sticky ? "y" : "") || "noGY";
regex[REGEX_DATA] = regex[REGEX_DATA] || {};
const r2 = regex[REGEX_DATA][cacheKey] || (regex[REGEX_DATA][cacheKey] = copyRegex(regex, {
addG: !!global2,
removeG: scope2 === "one",
isInternalOnly: true
}));
const result = String(nullThrows(str)).match(r2);
if (regex.global) {
regex.lastIndex = scope2 === "one" && result ? (
// Can't use `r2.lastIndex` since `r2` is nonglobal in this case
result.index + result[0].length
) : 0;
}
return global2 ? result || [] : result && result[0];
};
XRegExp.matchChain = (str, chain) => function recurseChain(values, level) {
const item = chain[level].regex ? chain[level] : { regex: chain[level] };
const matches = [];
function addMatch(match) {
if (item.backref) {
const ERR_UNDEFINED_GROUP = `Backreference to undefined group: ${item.backref}`;
const isNamedBackref = isNaN(item.backref);
if (isNamedBackref && XRegExp.isInstalled("namespacing")) {
if (!(match.groups && item.backref in match.groups)) {
throw new ReferenceError(ERR_UNDEFINED_GROUP);
}
} else if (!match.hasOwnProperty(item.backref)) {
throw new ReferenceError(ERR_UNDEFINED_GROUP);
}
const backrefValue = isNamedBackref && XRegExp.isInstalled("namespacing") ? match.groups[item.backref] : match[item.backref];
matches.push(backrefValue || "");
} else {
matches.push(match[0]);
}
}
for (const value of values) {
XRegExp.forEach(value, item.regex, addMatch);
}
return level === chain.length - 1 || !matches.length ? matches : recurseChain(matches, level + 1);
}([str], 0);
XRegExp.replace = (str, search, replacement, scope2) => {
const isRegex = XRegExp.isRegExp(search);
const global2 = search.global && scope2 !== "one" || scope2 === "all";
const cacheKey = (global2 ? "g" : "") + (search.sticky ? "y" : "") || "noGY";
let s2 = search;
if (isRegex) {
search[REGEX_DATA] = search[REGEX_DATA] || {};
s2 = search[REGEX_DATA][cacheKey] || (search[REGEX_DATA][cacheKey] = copyRegex(search, {
addG: !!global2,
removeG: scope2 === "one",
isInternalOnly: true
}));
} else if (global2) {
s2 = new RegExp(XRegExp.escape(String(search)), "g");
}
const result = fixed.replace.call(nullThrows(str), s2, replacement);
if (isRegex && search.global) {
search.lastIndex = 0;
}
return result;
};
XRegExp.replaceEach = (str, replacements) => {
for (const r of replacements) {
str = XRegExp.replace(str, r[0], r[1], r[2]);
}
return str;
};
XRegExp.split = (str, separator, limit) => fixed.split.call(nullThrows(str), separator, limit);
XRegExp.test = (str, regex, pos, sticky) => !!XRegExp.exec(str, regex, pos, sticky);
XRegExp.uninstall = (options2) => {
options2 = prepareOptions(options2);
if (features.astral && options2.astral) {
setAstral(false);
}
if (features.namespacing && options2.namespacing) {
setNamespacing(false);
}
};
XRegExp.union = (patterns, flags, options2) => {
options2 = options2 || {};
const conjunction = options2.conjunction || "or";
let numCaptures = 0;
let numPriorCaptures;
let captureNames;
function rewrite(match, paren, backref) {
const name2 = captureNames[numCaptures - numPriorCaptures];
if (paren) {
++numCaptures;
if (name2) {
return `(?<${name2}>`;
}
} else if (backref) {
return `\\${+backref + numPriorCaptures}`;
}
return match;
}
if (!(isType$1(patterns, "Array") && patterns.length)) {
throw new TypeError("Must provide a nonempty array of patterns to merge");
}
const parts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*\]/g;
const output = [];
for (const pattern2 of patterns) {
if (XRegExp.isRegExp(pattern2)) {
numPriorCaptures = numCaptures;
captureNames = pattern2[REGEX_DATA] && pattern2[REGEX_DATA].captureNames || [];
output.push(XRegExp(pattern2.source).source.replace(parts, rewrite));
} else {
output.push(XRegExp.escape(pattern2));
}
}
const separator = conjunction === "none" ? "" : "|";
return XRegExp(output.join(separator), flags);
};
fixed.exec = function(str) {
const origLastIndex = this.lastIndex;
const match = RegExp.prototype.exec.apply(this, arguments);
if (match) {
if (!correctExecNpcg && match.length > 1 && match.includes("")) {
const r2 = copyRegex(this, {
removeG: true,
isInternalOnly: true
});
String(str).slice(match.index).replace(r2, (...args) => {
const len = args.length;
for (let i = 1; i < len - 2; ++i) {
if (args[i] === void 0) {
match[i] = void 0;
}
}
});
}
if (this[REGEX_DATA] && this[REGEX_DATA].captureNames) {
let groupsObject = match;
if (XRegExp.isInstalled("namespacing")) {
match.groups = /* @__PURE__ */ Object.create(null);
groupsObject = match.groups;
}
for (let i = 1; i < match.length; ++i) {
const name2 = this[REGEX_DATA].captureNames[i - 1];
if (name2) {
groupsObject[name2] = match[i];
}
}
} else if (!match.groups && XRegExp.isInstalled("namespacing")) {
match.groups = void 0;
}
if (this.global && !match[0].length && this.lastIndex > match.index) {
this.lastIndex = match.index;
}
}
if (!this.global) {
this.lastIndex = origLastIndex;
}
return match;
};
fixed.test = function(str) {
return !!fixed.exec.call(this, str);
};
fixed.match = function(regex) {
if (!XRegExp.isRegExp(regex)) {
regex = new RegExp(regex);
} else if (regex.global) {
const result = String.prototype.match.apply(this, arguments);
regex.lastIndex = 0;
return result;
}
return fixed.exec.call(regex, nullThrows(this));
};
fixed.replace = function(search, replacement) {
const isRegex = XRegExp.isRegExp(search);
let origLastIndex;
let captureNames;
let result;
if (isRegex) {
if (search[REGEX_DATA]) {
({ captureNames } = search[REGEX_DATA]);
}
origLastIndex = search.lastIndex;
} else {
search += "";
}
if (isType$1(replacement, "Function")) {
result = String(this).replace(search, (...args) => {
if (captureNames) {
let groupsObject;
if (XRegExp.isInstalled("namespacing")) {
groupsObject = /* @__PURE__ */ Object.create(null);
args.push(groupsObject);
} else {
args[0] = new String(args[0]);
[groupsObject] = args;
}
for (let i = 0; i < captureNames.length; ++i) {
if (captureNames[i]) {
groupsObject[captureNames[i]] = args[i + 1];
}
}
}
return replacement(...args);
});
} else {
result = String(nullThrows(this)).replace(search, (...args) => {
return String(replacement).replace(replacementToken, replacer);
function replacer($0, bracketed, angled, dollarToken) {
bracketed = bracketed || angled;
const numNonCaptureArgs = isType$1(args[args.length - 1], "Object") ? 4 : 3;
const numCaptures = args.length - numNonCaptureArgs;
if (bracketed) {
if (/^\d+$/.test(bracketed)) {
const n2 = +bracketed;
if (n2 <= numCaptures) {
return args[n2] || "";
}
}
const n = captureNames ? captureNames.indexOf(bracketed) : -1;
if (n < 0) {
throw new SyntaxError(`Backreference to undefined group ${$0}`);
}
return args[n + 1] || "";
}
if (dollarToken === "" || dollarToken === " ") {
throw new SyntaxError(`Invalid token ${$0}`);
}
if (dollarToken === "&" || +dollarToken === 0) {
return args[0];
}
if (dollarToken === "$") {
return "$";
}
if (dollarToken === "`") {
return args[args.length - 1].slice(0, args[args.length - 2]);
}
if (dollarToken === "'") {
return args[args.length - 1].slice(args[args.length - 2] + args[0].length);
}
dollarToken = +dollarToken;
if (!isNaN(dollarToken)) {
if (dollarToken > numCaptures) {
throw new SyntaxError(`Backreference to undefined group ${$0}`);
}
return args[dollarToken] || "";
}
throw new SyntaxError(`Invalid token ${$0}`);
}
});
}
if (isRegex) {
if (search.global) {
search.lastIndex = 0;
} else {
search.lastIndex = origLastIndex;
}
}
return result;
};
fixed.split = function(separator, limit) {
if (!XRegExp.isRegExp(separator)) {
return String.prototype.split.apply(this, arguments);
}
const str = String(this);
const output = [];
const origLastIndex = separator.lastIndex;
let lastLastIndex = 0;
let lastLength;
limit = (limit === void 0 ? -1 : limit) >>> 0;
XRegExp.forEach(str, separator, (match) => {
if (match.index + match[0].length > lastLastIndex) {
output.push(str.slice(lastLastIndex, match.index));
if (match.length > 1 && match.index < str.length) {
Array.prototype.push.apply(output, match.slice(1));
}
lastLength = match[0].length;
lastLastIndex = match.index + lastLength;
}
});
if (lastLastIndex === str.length) {
if (!separator.test("") || lastLength) {
output.push("");
}
} else {
output.push(str.slice(lastLastIndex));
}
separator.lastIndex = origLastIndex;
return output.length > limit ? output.slice(0, limit) : output;
};
XRegExp.addToken(
/\\([ABCE-RTUVXYZaeg-mopqyz]|c(?![A-Za-z])|u(?![\dA-Fa-f]{4}|{[\dA-Fa-f]+})|x(?![\dA-Fa-f]{2}))/,
(match, scope2) => {
if (match[1] === "B" && scope2 === defaultScope) {
return match[0];
}
throw new SyntaxError(`Invalid escape ${match[0]}`);
},
{
scope: "all",
leadChar: "\\"
}
);
XRegExp.addToken(
/\\u{([\dA-Fa-f]+)}/,
(match, scope2, flags) => {
const code2 = dec(match[1]);
if (code2 > 1114111) {
throw new SyntaxError(`Invalid Unicode code point ${match[0]}`);
}
if (code2 <= 65535) {
return `\\u${pad4(hex(code2))}`;
}
if (hasNativeU && flags.includes("u")) {
return match[0];
}
throw new SyntaxError("Cannot use Unicode code point above \\u{FFFF} without flag u");
},
{
scope: "all",
leadChar: "\\"
}
);
XRegExp.addToken(
/\(\?#[^)]*\)/,
getContextualTokenSeparator,
{ leadChar: "(" }
);
XRegExp.addToken(
/\s+|#[^\n]*\n?/,
getContextualTokenSeparator,
{ flag: "x" }
);
if (!hasNativeS) {
XRegExp.addToken(
/\./,
() => "[\\s\\S]",
{
flag: "s",
leadChar: "."
}
);
}
XRegExp.addToken(
/\\k<([^>]+)>/,
function(match) {
const index = isNaN(match[1]) ? this.captureNames.indexOf(match[1]) + 1 : +match[1];
const endIndex = match.index + match[0].length;
if (!index || index > this.captureNames.length) {
throw new SyntaxError(`Backreference to undefined group ${match[0]}`);
}
return `\\${index}${endIndex === match.input.length || isNaN(match.input[endIndex]) ? "" : "(?:)"}`;
},
{ leadChar: "\\" }
);
XRegExp.addToken(
/\\(\d+)/,
function(match, scope2) {
if (!(scope2 === defaultScope && /^[1-9]/.test(match[1]) && +match[1] <= this.captureNames.length) && match[1] !== "0") {
throw new SyntaxError(`Cannot use octal escape or backreference to undefined group ${match[0]}`);
}
return match[0];
},
{
scope: "all",
leadChar: "\\"
}
);
XRegExp.addToken(
/\(\?P?<([\p{ID_Start}$_][\p{ID_Continue}$_\u200C\u200D]*)>/u,
function(match) {
if (!XRegExp.isInstalled("namespacing") && (match[1] === "length" || match[1] === "__proto__")) {
throw new SyntaxError(`Cannot use reserved word as capture name ${match[0]}`);
}
if (this.captureNames.includes(match[1])) {
throw new SyntaxError(`Cannot use same name for multiple groups ${match[0]}`);
}
this.captureNames.push(match[1]);
this.hasNamedCapture = true;
return "(";
},
{ leadChar: "(" }
);
XRegExp.addToken(
/\((?!\?)/,
function(match, scope2, flags) {
if (flags.includes("n")) {
return "(?:";
}
this.captureNames.push(null);
return "(";
},
{
optionalFlags: "n",
leadChar: "("
}
);
/*!
* XRegExp.build 5.1.1
* <xregexp.com>
* Steven Levithan (c) 2012-present MIT License
*/
const build = (XRegExp2) => {
const REGEX_DATA2 = "xregexp";
const subParts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*\]/g;
const parts = XRegExp2.union([/\({{([\w$]+)}}\)|{{([\w$]+)}}/, subParts], "g", {
conjunction: "or"
});
function deanchor(pattern2) {
const leadingAnchor = /^(?:\(\?:\))*\^/;
const trailingAnchor = /\$(?:\(\?:\))*$/;
if (leadingAnchor.test(pattern2) && trailingAnchor.test(pattern2) && // Ensure that the trailing `$` isn't escaped
trailingAnchor.test(pattern2.replace(/\\[\s\S]/g, ""))) {
return pattern2.replace(leadingAnchor, "").replace(trailingAnchor, "");
}
return pattern2;
}
function asXRegExp(value, addFlagX) {
const flags = addFlagX ? "x" : "";
return XRegExp2.isRegExp(value) ? value[REGEX_DATA2] && value[REGEX_DATA2].captureNames ? (
// Don't recompile, to preserve capture names
value
) : (
// Recompile as XRegExp
XRegExp2(value.source, flags)
) : (
// Compile string as XRegExp
XRegExp2(value, flags)
);
}
function interpolate(substitution) {
return substitution instanceof RegExp ? substitution : XRegExp2.escape(substitution);
}
function reduceToSubpatternsObject(subpatterns, interpolated, subpatternIndex) {
subpatterns[`subpattern${subpatternIndex}`] = interpolated;
return subpatterns;
}
function embedSubpatternAfter(raw, subpatternIndex, rawLiterals) {
const hasSubpattern = subpatternIndex < rawLiterals.length - 1;
return raw + (hasSubpattern ? `{{subpattern${subpatternIndex}}}` : "");
}
XRegExp2.tag = (flags) => (literals, ...substitutions) => {
const subpatterns = substitutions.map(interpolate).reduce(reduceToSubpatternsObject, {});
const pattern2 = literals.raw.map(embedSubpatternAfter).join("");
return XRegExp2.build(pattern2, subpatterns, flags);
};
XRegExp2.build = (pattern2, subs, flags) => {
flags = flags || "";
const addFlagX = flags.includes("x");
const inlineFlags = /^\(\?([\w$]+)\)/.exec(pattern2);
if (inlineFlags) {
flags = XRegExp2._clipDuplicates(flags + inlineFlags[1]);
}
const data = {};
for (const p in subs) {
if (subs.hasOwnProperty(p)) {
const sub = asXRegExp(subs[p], addFlagX);
data[p] = {
// Deanchoring allows embedding independently useful anchored regexes. If you
// really need to keep your anchors, double them (i.e., `^^...$$`).
pattern: deanchor(sub.source),
names: sub[REGEX_DATA2].captureNames || []
};
}
}
const patternAsRegex = asXRegExp(pattern2, addFlagX);
let numCaps = 0;
let numPriorCaps;
let numOuterCaps = 0;
const outerCapsMap = [0];
const outerCapNames = patternAsRegex[REGEX_DATA2].captureNames || [];
const output = patternAsRegex.source.replace(parts, ($0, $1, $2, $3, $4) => {
const subName = $1 || $2;
let capName;
let intro;
let localCapIndex;
if (subName) {
if (!data.hasOwnProperty(subName)) {
throw new ReferenceError(`Undefined property ${$0}`);
}
if ($1) {
capName = outerCapNames[numOuterCaps];
outerCapsMap[++numOuterCaps] = ++numCaps;
intro = `(?<${capName || subName}>`;
} else {
intro = "(?:";
}
numPriorCaps = numCaps;
const rewrittenSubpattern = data[subName].pattern.replace(subParts, (match, paren, backref) => {
if (paren) {
capName = data[subName].names[numCaps - numPriorCaps];
++numCaps;
if (capName) {
return `(?<${capName}>`;
}
} else if (backref) {
localCapIndex = +backref - 1;
return data[subName].names[localCapIndex] ? (
// Need to preserve the backreference name in case using flag `n`
`\\k<${data[subName].names[localCapIndex]}>`
) : `\\${+backref + numPriorCaps}`;
}
return match;
});
return `${intro}${rewrittenSubpattern})`;
}
if ($3) {
capName = outerCapNames[numOuterCaps];
outerCapsMap[++numOuterCaps] = ++numCaps;
if (capName) {
return `(?<${capName}>`;
}
} else if ($4) {
localCapIndex = +$4 - 1;
return outerCapNames[localCapIndex] ? (
// Need to preserve the backreference name in case using flag `n`
`\\k<${outerCapNames[localCapIndex]}>`
) : `\\${outerCapsMap[+$4]}`;
}
return $0;
});
return XRegExp2(output, flags);
};
};
/*!
* XRegExp.matchRecursive 5.1.1
* <xregexp.com>
* Steven Levithan (c) 2009-present MIT License
*/
const matchRecursive = (XRegExp2) => {
function row(name2, value, start, end) {
return {
name: name2,
value,
start,
end
};
}
XRegExp2.matchRecursive = (str, left, right, flags, options2) => {
flags = flags || "";
options2 = options2 || {};
const global2 = flags.includes("g");
const sticky = flags.includes("y");
const basicFlags = flags.replace(/y/g, "");
left = XRegExp2(left, basicFlags);
right = XRegExp2(right, basicFlags);
let esc;
let { escapeChar } = options2;
if (escapeChar) {
if (escapeChar.length > 1) {
throw new Error("Cannot use more than one escape character");
}
escapeChar = XRegExp2.escape(escapeChar);
esc = new RegExp(
`(?:${escapeChar}[\\S\\s]|(?:(?!${// Using `XRegExp.union` safely rewrites backreferences in `left` and `right`.
// Intentionally not passing `basicFlags` to `XRegExp.union` since any syntax
// transformation resulting from those flags was already applied to `left` and
// `right` when they were passed through the XRegExp constructor above.
XRegExp2.union([left, right], "", { conjunction: "or" }).source})[^${escapeChar}])+)+`,
// Flags `dgy` not needed here
flags.replace(XRegExp2._hasNativeFlag("s") ? /[^imsu]/g : /[^imu]/g, "")
);
}
let openTokens = 0;
let delimStart = 0;
let delimEnd = 0;
let lastOuterEnd = 0;
let outerStart;
let innerStart;
let leftMatch;
let rightMatch;
const vN = options2.valueNames;
const output = [];
while (true) {
if (escapeChar) {
delimEnd += (XRegExp2.exec(str, esc, delimEnd, "sticky") || [""])[0].length;
}
leftMatch = XRegExp2.exec(str, left, delimEnd);
rightMatch = XRegExp2.exec(str, right, delimEnd);
if (leftMatch && rightMatch) {
if (leftMatch.index <= rightMatch.index) {
rightMatch = null;
} else {
leftMatch = null;
}
}
if (leftMatch || rightMatch) {
delimStart = (leftMatch || rightMatch).index;
delimEnd = delimStart + (leftMatch || rightMatch)[0].length;
} else if (!openTokens) {
break;
}
if (sticky && !openTokens && delimStart > lastOuterEnd) {
break;
}
if (leftMatch) {
if (!openTokens) {
outerStart = delimStart;
innerStart = delimEnd;
}
openTokens += 1;
} else if (rightMatch && openTokens) {
openTokens -= 1;
if (!openTokens) {
if (vN) {
if (vN[0] && outerStart > lastOuterEnd) {
output.push(row(vN[0], str.slice(lastOuterEnd, outerStart), lastOuterEnd, outerStart));
}
if (vN[1]) {
output.push(row(vN[1], str.slice(outerStart, innerStart), outerStart, innerStart));
}
if (vN[2]) {
output.push(row(vN[2], str.slice(innerStart, delimStart), innerStart, delimStart));
}
if (vN[3]) {
output.push(row(vN[3], str.slice(delimStart, delimEnd), delimStart, delimEnd));
}
} else {
output.push(str.slice(innerStart, delimStart));
}
lastOuterEnd = delimEnd;
if (!global2) {
break;
}
}
} else {
const unbalanced = options2.unbalanced || "error";
if (unbalanced === "skip" || unbalanced === "skip-lazy") {
if (rightMatch) {
rightMatch = null;
} else {
if (unbalanced === "skip") {
const outerStartDelimLength = XRegExp2.exec(str, left, outerStart, "sticky")[0].length;
delimEnd = outerStart + (outerStartDelimLength || 1);
} else {
delimEnd = outerStart + 1;
}
openTokens = 0;
}
} else if (unbalanced === "error") {
const delimSide = rightMatch ? "right" : "left";
const errorPos = rightMatch ? delimStart : outerStart;
throw new Error(`Unbalanced ${delimSide} delimiter found in string at position ${errorPos}`);
} else {
throw new Error(`Unsupported value for unbalanced: ${unbalanced}`);
}
}
if (delimStart === delimEnd) {
delimEnd += 1;
}
}
if (global2 && output.length > 0 && !sticky && vN && vN[0] && str.length > lastOuterEnd) {
output.push(row(vN[0], str.slice(lastOuterEnd), lastOuterEnd, str.length));
}
return output;
};
};
/*!
* XRegExp Unicode Base 5.1.1
* <xregexp.com>
* Steven Levithan (c) 2008-present MIT License
*/
const unicodeBase = (XRegExp2) => {
const unicode = {};
const unicodeTypes = {};
const dec2 = XRegExp2._dec;
const hex2 = XRegExp2._hex;
const pad42 = XRegExp2._pad4;
function normalize(name2) {
return name2.replace(/[- _]+/g, "").toLowerCase();
}
function charCode(chr) {
const esc = /^\\[xu](.+)/.exec(chr);
return esc ? dec2(esc[1]) : chr.charCodeAt(chr[0] === "\\" ? 1 : 0);
}
function invertBmp(range) {
let output = "";
let lastEnd = -1;
XRegExp2.forEach(
range,
/(\\x..|\\u....|\\?[\s\S])(?:-(\\x..|\\u....|\\?[\s\S]))?/,
(m) => {
const start = charCode(m[1]);
if (start > lastEnd + 1) {
output += `\\u${pad42(hex2(lastEnd + 1))}`;
if (start > lastEnd + 2) {
output += `-\\u${pad42(hex2(start - 1))}`;
}
}
lastEnd = charCode(m[2] || m[1]);
}
);
if (lastEnd < 65535) {
output += `\\u${pad42(hex2(lastEnd + 1))}`;
if (lastEnd < 65534) {
output += "-\\uFFFF";
}
}
return output;
}
function cacheInvertedBmp(slug) {
const prop = "b!";
return unicode[slug][prop] || (unicode[slug][prop] = invertBmp(unicode[slug].bmp));
}
function buildAstral(slug, isNegated) {
const item = unicode[slug];
let combined = "";
if (item.bmp && !item.isBmpLast) {
combined = `[${item.bmp}]${item.astral ? "|" : ""}`;
}
if (item.astral) {
combined += item.astral;
}
if (item.isBmpLast && item.bmp) {
combined += `${item.astral ? "|" : ""}[${item.bmp}]`;
}
return isNegated ? `(?:(?!${combined})(?:[\uD800-\uDBFF][\uDC00-\uDFFF]|[\0-]))` : `(?:${combined})`;
}
function cacheAstral(slug, isNegated) {
const prop = isNegated ? "a!" : "a=";
return unicode[slug][prop] || (unicode[slug][prop] = buildAstral(slug, isNegated));
}
XRegExp2.addToken(
// Use `*` instead of `+` to avoid capturing `^` as the token name in `\p{^}`
/\\([pP])(?:{(\^?)(?:(\w+)=)?([^}]*)}|([A-Za-z]))/,
(match, scope2, flags) => {
const ERR_DOUBLE_NEG = "Invalid double negation ";
const ERR_UNKNOWN_NAME = "Unknown Unicode token ";
const ERR_UNKNOWN_REF = "Unicode token missing data ";
const ERR_ASTRAL_ONLY = "Astral mode required for Unicode token ";
const ERR_ASTRAL_IN_CLASS = "Astral mode does not support Unicode tokens within character classes";
const [
fullToken,
pPrefix,
caretNegation,
typePrefix,
tokenName,
tokenSingleCharName
] = match;
let isNegated = pPrefix === "P" || !!caretNegation;
const isAstralMode = flags.includes("A");
let slug = normalize(tokenSingleCharName || tokenName);
let item = unicode[slug];
if (pPrefix === "P" && caretNegation) {
throw new SyntaxError(ERR_DOUBLE_NEG + fullToken);
}
if (!unicode.hasOwnProperty(slug)) {
throw new SyntaxError(ERR_UNKNOWN_NAME + fullToken);
}
if (typePrefix) {
if (!(unicodeTypes[typePrefix] && unicodeTypes[typePrefix][slug])) {
throw new SyntaxError(ERR_UNKNOWN_NAME + fullToken);
}
}
if (item.inverseOf) {
slug = normalize(item.inverseOf);
if (!unicode.hasOwnProperty(slug)) {
throw new ReferenceError(`${ERR_UNKNOWN_REF + fullToken} -> ${item.inverseOf}`);
}
item = unicode[slug];
isNegated = !isNegated;
}
if (!(item.bmp || isAstralMode)) {
throw new SyntaxError(ERR_ASTRAL_ONLY + fullToken);
}
if (isAstralMode) {
if (scope2 === "class") {
throw new SyntaxError(ERR_ASTRAL_IN_CLASS);
}
return cacheAstral(slug, isNegated);
}
return scope2 === "class" ? isNegated ? cacheInvertedBmp(slug) : item.bmp : `${(isNegated ? "[^" : "[") + item.bmp}]`;
},
{
scope: "all",
optionalFlags: "A",
leadChar: "\\"
}
);
XRegExp2.addUnicodeData = (data, typePrefix) => {
const ERR_NO_NAME = "Unicode token requires name";
const ERR_NO_DATA = "Unicode token has no character data ";
if (typePrefix) {
unicodeTypes[typePrefix] = {};
}
for (const item of data) {
if (!item.name) {
throw new Error(ERR_NO_NAME);
}
if (!(item.inverseOf || item.bmp || item.astral)) {
throw new Error(ERR_NO_DATA + item.name);
}
const normalizedName = normalize(item.name);
unicode[normalizedName] = item;
if (typePrefix) {
unicodeTypes[typePrefix][normalizedName] = true;
}
if (item.alias) {
const normalizedAlias = normalize(item.alias);
unicode[normalizedAlias] = item;
if (typePrefix) {
unicodeTypes[typePrefix][normalizedAlias] = true;
}
}
}
XRegExp2.cache.flush("patterns");
};
XRegExp2._getUnicodeProperty = (name2) => {
const slug = normalize(name2);
return unicode[slug];
};
};
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
function getDefaultExportFromCjs(x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
}
function getAugmentedNamespace(n) {
if (n.__esModule)
return n;
var f = n.default;
if (typeof f == "function") {
var a = function a2() {
if (this instanceof a2) {
return Reflect.construct(f, arguments, this.constructor);
}
return f.apply(this, arguments);
};
a.prototype = f.prototype;
} else
a = {};
Object.defineProperty(a, "__esModule", { value: true });
Object.keys(n).forEach(function(k) {
var d = Object.getOwnPropertyDescriptor(n, k);
Object.defineProperty(a, k, d.get ? d : {
enumerable: true,
get: function() {
return n[k];
}
});
});
return a;
}
var categories = [
{
"name": "C",
"alias": "Other",
"isBmpLast": true,
"bmp": "\0- ------------------------------------ೳ---------໎----------------------------------------------------⿼-⿿--㇯-----------------------------------",
"astral": "\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDCFF\uDD03-\uDD06\uDD34-\uDD36\uDD8F\uDD9D-\uDD9F\uDDA1-\uDDCF\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEFC-\uDEFF\uDF24-\uDF2C\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDFC4-\uDFC7\uDFD6-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCAF\uDCD4-\uDCD7\uDCFC-\uDCFF\uDD28-\uDD2F\uDD64-\uDD6E\uDD7B\uDD8B\uDD93\uDD96\uDDA2\uDDB2\uDDBA\uDDBD-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDF7F\uDF86\uDFB1\uDFBB-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56\uDC9F-\uDCA6\uDCB0-\uDCDF\uDCF3\uDCF6-\uDCFA\uDD1C-\uDD1E\uDD3A-\uDD3E\uDD40-\uDD7F\uDDB8-\uDDBB\uDDD0\uDDD1\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE36\uDE37\uDE3B-\uDE3E\uDE49-\uDE4F\uDE59-\uDE5F\uDEA0-\uDEBF\uDEE7-\uDEEA\uDEF7-\uDEFF\uDF36-\uDF38\uDF56\uDF57\uDF73-\uDF77\uDF92-\uDF98\uDF9D-\uDFA8\uDFB0-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCF9\uDD28-\uDD2F\uDD3A-\uDE5F\uDE7F\uDEAA\uDEAE\uDEAF\uDEB2-\uDEFF\uDF28-\uDF2F\uDF5A-\uDF6F\uDF8A-\uDFAF\uDFCC-\uDFDF\uDFF7-\uDFFF]|\uD804[\uDC4E-\uDC51\uDC76-\uDC7E\uDCBD\uDCC3-\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD48-\uDD4F\uDD77-\uDD7F\uDDE0\uDDF5-\uDDFF\uDE12\uDE3F-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEAA-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD805[\uDC5C\uDC62-\uDC7F\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDDE-\uDDFF\uDE45-\uDE4F\uDE5A-\uDE5F\uDE6D-\uDE7F\uDEBA-\uDEBF\uDECA-\uDEFF\uDF1B\uDF1C\uDF2C-\uDF2F\uDF47-\uDFFF]|\uD806[\uDC3C-\uDC9F\uDCF3-\uDCFE\uDD07\uDD08\uDD0A\uDD0B\uDD14\uDD17\uDD36\uDD39\uDD3A\uDD47-\uDD4F\uDD5A-\uDD9F\uDDA8\uDDA9\uDDD8\uDDD9\uDDE5-\uDDFF\uDE48-\uDE4F\uDEA3-\uDEAF\uDEF9-\uDFFF]|\uD807[\uDC09\uDC37\uDC46-\uDC4F\uDC6D-\uDC6F\uDC90\uDC91\uDCA8\uDCB7-\uDCFF\uDD07\uDD0A\uDD37-\uDD39\uDD3B\uDD3E\uDD48-\uDD4F\uDD5A-\uDD5F\uDD66\uDD69\uDD8F\uDD92\uDD99-\uDD9F\uDDAA-\uDEDF\uDEF9-\uDFAF\uDFB1-\uDFBF\uDFF2-\uDFFE]|\uD808[\uDF9A-\uDFFF]|\uD809[\uDC6F\uDC75-\uDC7F\uDD44-\uDFFF]|[\uD80A\uD80E-\uD810\uD812-\uD819\uD824-\uD82A\uD82D\uD82E\uD830-\uD832\uD83F\uD87B-\uD87D\uD87F\uD885-\uDB3F\uDB41-\uDBFF][\uDC00-\uDFFF]|\uD80B[\uDC00-\uDF8F\uDFF3-\uDFFF]|\uD80D[\uDC2F-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDE6D\uDEBF\uDECA-\uDECF\uDEEE\uDEEF\uDEF6-\uDEFF\uDF46-\uDF4F\uDF5A\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD81B[\uDC00-\uDE3F\uDE9B-\uDEFF\uDF4B-\uDF4E\uDF88-\uDF8E\uDFA0-\uDFDF\uDFE5-\uDFEF\uDFF2-\uDFFF]|\uD821[\uDFF8-\uDFFF]|\uD823[\uDCD6-\uDCFF\uDD09-\uDFFF]|\uD82B[\uDC00-\uDFEF\uDFF4\uDFFC\uDFFF]|\uD82C[\uDD23-\uDD4F\uDD53-\uDD63\uDD68-\uDD6F\uDEFC-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A\uDC9B\uDCA0-\uDFFF]|\uD833[\uDC00-\uDEFF\uDF2E\uDF2F\uDF47-\uDF4F\uDFC4-\uDFFF]|\uD834[\uDCF6-\uDCFF\uDD27\uDD28\uDD73-\uDD7A\uDDEB-\uDDFF\uDE46-\uDEDF\uDEF4-\uDEFF\uDF57-\uDF5F\uDF79-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDFCC\uDFCD]|\uD836[\uDE8C-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD837[\uDC00-\uDEFF\uDF1F-\uDFFF]|\uD838[\uDC07\uDC19\uDC1A\uDC22\uDC25\uDC2B-\uDCFF\uDD2D-\uDD2F\uDD3E\uDD3F\uDD4A-\uDD4D\uDD50-\uDE8F\uDEAF-\uDEBF\uDEFA-\uDEFE\uDF00-\uDFFF]|\uD839[\uDC00-\uDFDF\uDFE7\uDFEC\uDFEF\uDFFF]|\uD83A[\uDCC5\uDCC6\uDCD7-\uDCFF\uDD4C-\uDD4F\uDD5A-\uDD5D\uDD60-\uDFFF]|\uD83B[\uDC00-\uDC70\uDCB5-\uDD00\uDD3E-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDEEF\uDEF2-\uDFFF]|\uD83C[\uDC2C-\uDC2F\uDC94-\uDC9F\uDCAF\uDCB0\uDCC0\uDCD0\uDCF6-\uDCFF\uDDAE-\uDDE5\uDE03-\uDE0F\uDE3C-\uDE3F\uDE49-\uDE4F\uDE52-\uDE5F\uDE66-\uDEFF]|\uD83D[\uDED8-\uDEDC\uDEED-\uDEEF\uDEFD-\uDEFF\uDF74-\uDF7F\uDFD9-\uDFDF\uDFEC-\uDFEF\uDFF1-\uDFFF]|\uD83E[\uDC0C-\uDC0F\uDC48-\uDC4F\uDC5A-\uDC5F\uDC88-\uDC8F\uDCAE\uDCAF\uDCB2-\uDCFF\uDE54-\uDE5F\uDE6E\uDE6F\uDE75-\uDE77\uDE7D-\uDE7F\uDE87-\uDE8F\uDEAD-\uDEAF\uDEBB-\uDEBF\uDEC6-\uDECF\uDEDA-\uDEDF\uDEE8-\uDEEF\uDEF7-\uDEFF\uDF93\uDFCB-\uDFEF\uDFFA-\uDFFF]|\uD869[\uDEE0-\uDEFF]|\uD86D[\uDF39-\uDF3F]|\uD86E[\uDC1E\uDC1F]|\uD873[\uDEA2-\uDEAF]|\uD87A[\uDFE1-\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uD884[\uDF4B-\uDFFF]|\uDB40[\uDC00-\uDCFF\uDDF0-\uDFFF]"
},
{
"name": "Cc",
"alias": "Control",
"bmp": "\0- -"
},
{
"name": "Cf",
"alias": "Format",
"bmp": "-----\uFEFF-",
"astral": "\uD804[\uDCBD\uDCCD]|\uD80D[\uDC30-\uDC38]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]"
},
{
"name": "Cn",
"alias": "Unassigned",
"bmp": "-----------------------------------ೳ---------໎-------------------------------------------------⿼-⿿--㇯----------------------------------",
"astral": "\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDCFF\uDD03-\uDD06\uDD34-\uDD36\uDD8F\uDD9D-\uDD9F\uDDA1-\uDDCF\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEFC-\uDEFF\uDF24-\uDF2C\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDFC4-\uDFC7\uDFD6-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCAF\uDCD4-\uDCD7\uDCFC-\uDCFF\uDD28-\uDD2F\uDD64-\uDD6E\uDD7B\uDD8B\uDD93\uDD96\uDDA2\uDDB2\uDDBA\uDDBD-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDF7F\uDF86\uDFB1\uDFBB-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56\uDC9F-\uDCA6\uDCB0-\uDCDF\uDCF3\uDCF6-\uDCFA\uDD1C-\uDD1E\uDD3A-\uDD3E\uDD40-\uDD7F\uDDB8-\uDDBB\uDDD0\uDDD1\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE36\uDE37\uDE3B-\uDE3E\uDE49-\uDE4F\uDE59-\uDE5F\uDEA0-\uDEBF\uDEE7-\uDEEA\uDEF7-\uDEFF\uDF36-\uDF38\uDF56\uDF57\uDF73-\uDF77\uDF92-\uDF98\uDF9D-\uDFA8\uDFB0-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCF9\uDD28-\uDD2F\uDD3A-\uDE5F\uDE7F\uDEAA\uDEAE\uDEAF\uDEB2-\uDEFF\uDF28-\uDF2F\uDF5A-\uDF6F\uDF8A-\uDFAF\uDFCC-\uDFDF\uDFF7-\uDFFF]|\uD804[\uDC4E-\uDC51\uDC76-\uDC7E\uDCC3-\uDCCC\uDCCE\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD48-\uDD4F\uDD77-\uDD7F\uDDE0\uDDF5-\uDDFF\uDE12\uDE3F-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEAA-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD805[\uDC5C\uDC62-\uDC7F\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDDE-\uDDFF\uDE45-\uDE4F\uDE5A-\uDE5F\uDE6D-\uDE7F\uDEBA-\uDEBF\uDECA-\uDEFF\uDF1B\uDF1C\uDF2C-\uDF2F\uDF47-\uDFFF]|\uD806[\uDC3C-\uDC9F\uDCF3-\uDCFE\uDD07\uDD08\uDD0A\uDD0B\uDD14\uDD17\uDD36\uDD39\uDD3A\uDD47-\uDD4F\uDD5A-\uDD9F\uDDA8\uDDA9\uDDD8\uDDD9\uDDE5-\uDDFF\uDE48-\uDE4F\uDEA3-\uDEAF\uDEF9-\uDFFF]|\uD807[\uDC09\uDC37\uDC46-\uDC4F\uDC6D-\uDC6F\uDC90\uDC91\uDCA8\uDCB7-\uDCFF\uDD07\uDD0A\uDD37-\uDD39\uDD3B\uDD3E\uDD48-\uDD4F\uDD5A-\uDD5F\uDD66\uDD69\uDD8F\uDD92\uDD99-\uDD9F\uDDAA-\uDEDF\uDEF9-\uDFAF\uDFB1-\uDFBF\uDFF2-\uDFFE]|\uD808[\uDF9A-\uDFFF]|\uD809[\uDC6F\uDC75-\uDC7F\uDD44-\uDFFF]|[\uD80A\uD80E-\uD810\uD812-\uD819\uD824-\uD82A\uD82D\uD82E\uD830-\uD832\uD83F\uD87B-\uD87D\uD87F\uD885-\uDB3F\uDB41-\uDB7F][\uDC00-\uDFFF]|\uD80B[\uDC00-\uDF8F\uDFF3-\uDFFF]|\uD80D[\uDC2F\uDC39-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDE6D\uDEBF\uDECA-\uDECF\uDEEE\uDEEF\uDEF6-\uDEFF\uDF46-\uDF4F\uDF5A\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD81B[\uDC00-\uDE3F\uDE9B-\uDEFF\uDF4B-\uDF4E\uDF88-\uDF8E\uDFA0-\uDFDF\uDFE5-\uDFEF\uDFF2-\uDFFF]|\uD821[\uDFF8-\uDFFF]|\uD823[\uDCD6-\uDCFF\uDD09-\uDFFF]|\uD82B[\uDC00-\uDFEF\uDFF4\uDFFC\uDFFF]|\uD82C[\uDD23-\uDD4F\uDD53-\uDD63\uDD68-\uDD6F\uDEFC-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-