visitLiteral(literal) {

[32000] Fix | Delete

this.parts.push(literal.number);

[32001] Fix | Delete

}

[32002] Fix | Delete

visitBinaryOperation(operation) {

[32003] Fix | Delete

this.parts.push("(");

[32004] Fix | Delete

operation.arg1.visit(this);

[32005] Fix | Delete

this.parts.push(" ", operation.op, " ");

[32006] Fix | Delete

operation.arg2.visit(this);

[32007] Fix | Delete

this.parts.push(")");

[32008] Fix | Delete

}

[32009] Fix | Delete

visitVariableDefinition(definition) {

[32010] Fix | Delete

this.parts.push("var ");

[32011] Fix | Delete

definition.variable.visit(this);

[32012] Fix | Delete

this.parts.push(" = ");

[32013] Fix | Delete

definition.arg.visit(this);

[32014] Fix | Delete

this.parts.push(";");

[32015] Fix | Delete

}

[32016] Fix | Delete

visitMin(max) {

[32017] Fix | Delete

this.parts.push("Math.min(");

[32018] Fix | Delete

max.arg.visit(this);

[32019] Fix | Delete

this.parts.push(", ", max.max, ")");

[32020] Fix | Delete

}

[32021] Fix | Delete

toString() {

[32022] Fix | Delete

return this.parts.join("");

[32023] Fix | Delete

}

[32024] Fix | Delete

}

[32025] Fix | Delete

function buildAddOperation(num1, num2) {

[32026] Fix | Delete

if (num2.type === "literal" && num2.number === 0) {

[32027] Fix | Delete

return num1;

[32028] Fix | Delete

}

[32029] Fix | Delete

if (num1.type === "literal" && num1.number === 0) {

[32030] Fix | Delete

return num2;

[32031] Fix | Delete

}

[32032] Fix | Delete

if (num2.type === "literal" && num1.type === "literal") {

[32033] Fix | Delete

return new AstLiteral(num1.number + num2.number);

[32034] Fix | Delete

}

[32035] Fix | Delete

return new AstBinaryOperation("+", num1, num2, num1.min + num2.min, num1.max + num2.max);

[32036] Fix | Delete

}

[32037] Fix | Delete

function buildMulOperation(num1, num2) {

[32038] Fix | Delete

if (num2.type === "literal") {

[32039] Fix | Delete

if (num2.number === 0) {

[32040] Fix | Delete

return new AstLiteral(0);

[32041] Fix | Delete

} else if (num2.number === 1) {

[32042] Fix | Delete

return num1;

[32043] Fix | Delete

} else if (num1.type === "literal") {

[32044] Fix | Delete

return new AstLiteral(num1.number * num2.number);

[32045] Fix | Delete

}

[32046] Fix | Delete

}

[32047] Fix | Delete

if (num1.type === "literal") {

[32048] Fix | Delete

if (num1.number === 0) {

[32049] Fix | Delete

return new AstLiteral(0);

[32050] Fix | Delete

} else if (num1.number === 1) {

[32051] Fix | Delete

return num2;

[32052] Fix | Delete

}

[32053] Fix | Delete

}

[32054] Fix | Delete

const min = Math.min(num1.min * num2.min, num1.min * num2.max, num1.max * num2.min, num1.max * num2.max);

[32055] Fix | Delete

const max = Math.max(num1.min * num2.min, num1.min * num2.max, num1.max * num2.min, num1.max * num2.max);

[32056] Fix | Delete

return new AstBinaryOperation("*", num1, num2, min, max);

[32057] Fix | Delete

}

[32058] Fix | Delete

function buildSubOperation(num1, num2) {

[32059] Fix | Delete

if (num2.type === "literal") {

[32060] Fix | Delete

if (num2.number === 0) {

[32061] Fix | Delete

return num1;

[32062] Fix | Delete

} else if (num1.type === "literal") {

[32063] Fix | Delete

return new AstLiteral(num1.number - num2.number);

[32064] Fix | Delete

}

[32065] Fix | Delete

}

[32066] Fix | Delete

if (num2.type === "binary" && num2.op === "-" && num1.type === "literal" && num1.number === 1 && num2.arg1.type === "literal" && num2.arg1.number === 1) {

[32067] Fix | Delete

return num2.arg2;

[32068] Fix | Delete

}

[32069] Fix | Delete

return new AstBinaryOperation("-", num1, num2, num1.min - num2.max, num1.max - num2.min);

[32070] Fix | Delete

}

[32071] Fix | Delete

function buildMinOperation(num1, max) {

[32072] Fix | Delete

if (num1.min >= max) {

[32073] Fix | Delete

return new AstLiteral(max);

[32074] Fix | Delete

} else if (num1.max <= max) {

[32075] Fix | Delete

return num1;

[32076] Fix | Delete

}

[32077] Fix | Delete

return new AstMin(num1, max);

[32078] Fix | Delete

}

[32079] Fix | Delete

class PostScriptCompiler {

[32080] Fix | Delete

compile(code, domain, range) {

[32081] Fix | Delete

const stack = [];

[32082] Fix | Delete

const instructions = [];

[32083] Fix | Delete

const inputSize = domain.length >> 1,

[32084] Fix | Delete

outputSize = range.length >> 1;

[32085] Fix | Delete

let lastRegister = 0;

[32086] Fix | Delete

let n, j;

[32087] Fix | Delete

let num1, num2, ast1, ast2, tmpVar, item;

[32088] Fix | Delete

for (let i = 0; i < inputSize; i++) {

[32089] Fix | Delete

stack.push(new AstArgument(i, domain[i * 2], domain[i * 2 + 1]));

[32090] Fix | Delete

}

[32091] Fix | Delete

for (let i = 0, ii = code.length; i < ii; i++) {

[32092] Fix | Delete

item = code[i];

[32093] Fix | Delete

if (typeof item === "number") {

[32094] Fix | Delete

stack.push(new AstLiteral(item));

[32095] Fix | Delete

continue;

[32096] Fix | Delete

}

[32097] Fix | Delete

switch (item) {

[32098] Fix | Delete

case "add":

[32099] Fix | Delete

if (stack.length < 2) {

[32100] Fix | Delete

return null;

[32101] Fix | Delete

}

[32102] Fix | Delete

num2 = stack.pop();

[32103] Fix | Delete

num1 = stack.pop();

[32104] Fix | Delete

stack.push(buildAddOperation(num1, num2));

[32105] Fix | Delete

break;

[32106] Fix | Delete

case "cvr":

[32107] Fix | Delete

if (stack.length < 1) {

[32108] Fix | Delete

return null;

[32109] Fix | Delete

}

[32110] Fix | Delete

break;

[32111] Fix | Delete

case "mul":

[32112] Fix | Delete

if (stack.length < 2) {

[32113] Fix | Delete

return null;

[32114] Fix | Delete

}

[32115] Fix | Delete

num2 = stack.pop();

[32116] Fix | Delete

num1 = stack.pop();

[32117] Fix | Delete

stack.push(buildMulOperation(num1, num2));

[32118] Fix | Delete

break;

[32119] Fix | Delete

case "sub":

[32120] Fix | Delete

if (stack.length < 2) {

[32121] Fix | Delete

return null;

[32122] Fix | Delete

}

[32123] Fix | Delete

num2 = stack.pop();

[32124] Fix | Delete

num1 = stack.pop();

[32125] Fix | Delete

stack.push(buildSubOperation(num1, num2));

[32126] Fix | Delete

break;

[32127] Fix | Delete

case "exch":

[32128] Fix | Delete

if (stack.length < 2) {

[32129] Fix | Delete

return null;

[32130] Fix | Delete

}

[32131] Fix | Delete

ast1 = stack.pop();

[32132] Fix | Delete

ast2 = stack.pop();

[32133] Fix | Delete

stack.push(ast1, ast2);

[32134] Fix | Delete

break;

[32135] Fix | Delete

case "pop":

[32136] Fix | Delete

if (stack.length < 1) {

[32137] Fix | Delete

return null;

[32138] Fix | Delete

}

[32139] Fix | Delete

stack.pop();

[32140] Fix | Delete

break;

[32141] Fix | Delete

case "index":

[32142] Fix | Delete

if (stack.length < 1) {

[32143] Fix | Delete

return null;

[32144] Fix | Delete

}

[32145] Fix | Delete

num1 = stack.pop();

[32146] Fix | Delete

if (num1.type !== "literal") {

[32147] Fix | Delete

return null;

[32148] Fix | Delete

}

[32149] Fix | Delete

n = num1.number;

[32150] Fix | Delete

if (n < 0 || !Number.isInteger(n) || stack.length < n) {

[32151] Fix | Delete

return null;

[32152] Fix | Delete

}

[32153] Fix | Delete

ast1 = stack[stack.length - n - 1];

[32154] Fix | Delete

if (ast1.type === "literal" || ast1.type === "var") {

[32155] Fix | Delete

stack.push(ast1);

[32156] Fix | Delete

break;

[32157] Fix | Delete

}

[32158] Fix | Delete

tmpVar = new AstVariable(lastRegister++, ast1.min, ast1.max);

[32159] Fix | Delete

stack[stack.length - n - 1] = tmpVar;

[32160] Fix | Delete

stack.push(tmpVar);

[32161] Fix | Delete

instructions.push(new AstVariableDefinition(tmpVar, ast1));

[32162] Fix | Delete

break;

[32163] Fix | Delete

case "dup":

[32164] Fix | Delete

if (stack.length < 1) {

[32165] Fix | Delete

return null;

[32166] Fix | Delete

}

[32167] Fix | Delete

if (typeof code[i + 1] === "number" && code[i + 2] === "gt" && code[i + 3] === i + 7 && code[i + 4] === "jz" && code[i + 5] === "pop" && code[i + 6] === code[i + 1]) {

[32168] Fix | Delete

num1 = stack.pop();

[32169] Fix | Delete

stack.push(buildMinOperation(num1, code[i + 1]));

[32170] Fix | Delete

i += 6;

[32171] Fix | Delete

break;

[32172] Fix | Delete

}

[32173] Fix | Delete

ast1 = stack.at(-1);

[32174] Fix | Delete

if (ast1.type === "literal" || ast1.type === "var") {

[32175] Fix | Delete

stack.push(ast1);

[32176] Fix | Delete

break;

[32177] Fix | Delete

}

[32178] Fix | Delete

tmpVar = new AstVariable(lastRegister++, ast1.min, ast1.max);

[32179] Fix | Delete

stack[stack.length - 1] = tmpVar;

[32180] Fix | Delete

stack.push(tmpVar);

[32181] Fix | Delete

instructions.push(new AstVariableDefinition(tmpVar, ast1));

[32182] Fix | Delete

break;

[32183] Fix | Delete

case "roll":

[32184] Fix | Delete

if (stack.length < 2) {

[32185] Fix | Delete

return null;

[32186] Fix | Delete

}

[32187] Fix | Delete

num2 = stack.pop();

[32188] Fix | Delete

num1 = stack.pop();

[32189] Fix | Delete

if (num2.type !== "literal" || num1.type !== "literal") {

[32190] Fix | Delete

return null;

[32191] Fix | Delete

}

[32192] Fix | Delete

j = num2.number;

[32193] Fix | Delete

n = num1.number;

[32194] Fix | Delete

if (n <= 0 || !Number.isInteger(n) || !Number.isInteger(j) || stack.length < n) {

[32195] Fix | Delete

return null;

[32196] Fix | Delete

}

[32197] Fix | Delete

j = (j % n + n) % n;

[32198] Fix | Delete

if (j === 0) {

[32199] Fix | Delete

break;

[32200] Fix | Delete

}

[32201] Fix | Delete

stack.push(...stack.splice(stack.length - n, n - j));

[32202] Fix | Delete

break;

[32203] Fix | Delete

default:

[32204] Fix | Delete

return null;

[32205] Fix | Delete

}

[32206] Fix | Delete

}

[32207] Fix | Delete

if (stack.length !== outputSize) {

[32208] Fix | Delete

return null;

[32209] Fix | Delete

}

[32210] Fix | Delete

const result = [];

[32211] Fix | Delete

for (const instruction of instructions) {

[32212] Fix | Delete

const statementBuilder = new ExpressionBuilderVisitor();

[32213] Fix | Delete

instruction.visit(statementBuilder);

[32214] Fix | Delete

result.push(statementBuilder.toString());

[32215] Fix | Delete

}

[32216] Fix | Delete

for (let i = 0, ii = stack.length; i < ii; i++) {

[32217] Fix | Delete

const expr = stack[i],

[32218] Fix | Delete

statementBuilder = new ExpressionBuilderVisitor();

[32219] Fix | Delete

expr.visit(statementBuilder);

[32220] Fix | Delete

const min = range[i * 2],

[32221] Fix | Delete

max = range[i * 2 + 1];

[32222] Fix | Delete

const out = [statementBuilder.toString()];

[32223] Fix | Delete

if (min > expr.min) {

[32224] Fix | Delete

out.unshift("Math.max(", min, ", ");

[32225] Fix | Delete

out.push(")");

[32226] Fix | Delete

}

[32227] Fix | Delete

if (max < expr.max) {

[32228] Fix | Delete

out.unshift("Math.min(", max, ", ");

[32229] Fix | Delete

out.push(")");

[32230] Fix | Delete

}

[32231] Fix | Delete

out.unshift("dest[destOffset + ", i, "] = ");

[32232] Fix | Delete

out.push(";");

[32233] Fix | Delete

result.push(out.join(""));

[32234] Fix | Delete

}

[32235] Fix | Delete

return result.join("\n");

[32236] Fix | Delete

}

[32237] Fix | Delete

}

[32238] Fix | Delete

[32239] Fix | Delete

;// CONCATENATED MODULE: ./src/core/bidi.js

[32240] Fix | Delete

[32241] Fix | Delete

const baseTypes = ["BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "S", "B", "S", "WS", "B", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "B", "B", "B", "S", "WS", "ON", "ON", "ET", "ET", "ET", "ON", "ON", "ON", "ON", "ON", "ES", "CS", "ES", "CS", "CS", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "CS", "ON", "ON", "ON", "ON", "ON", "ON", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "ON", "ON", "ON", "ON", "ON", "ON", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "ON", "ON", "ON", "ON", "BN", "BN", "BN", "BN", "BN", "BN", "B", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "CS", "ON", "ET", "ET", "ET", "ET", "ON", "ON", "ON", "ON", "L", "ON", "ON", "BN", "ON", "ON", "ET", "ET", "EN", "EN", "ON", "L", "ON", "ON", "ON", "EN", "L", "ON", "ON", "ON", "ON", "ON", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "ON", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "ON", "L", "L", "L", "L", "L", "L", "L", "L"];

[32242] Fix | Delete

const arabicTypes = ["AN", "AN", "AN", "AN", "AN", "AN", "ON", "ON", "AL", "ET", "ET", "AL", "CS", "AL", "ON", "ON", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "AL", "AL", "", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "AN", "AN", "AN", "AN", "AN", "AN", "AN", "AN", "AN", "AN", "ET", "AN", "AN", "AL", "AL", "AL", "NSM", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "AN", "ON", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "AL", "AL", "NSM", "NSM", "ON", "NSM", "NSM", "NSM", "NSM", "AL", "AL", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "AL", "AL", "AL", "AL", "AL", "AL"];

[32243] Fix | Delete

function isOdd(i) {

[32244] Fix | Delete

return (i & 1) !== 0;

[32245] Fix | Delete

}

[32246] Fix | Delete

function isEven(i) {

[32247] Fix | Delete

return (i & 1) === 0;

[32248] Fix | Delete

}

[32249] Fix | Delete

function findUnequal(arr, start, value) {

[32250] Fix | Delete

let j, jj;

[32251] Fix | Delete

for (j = start, jj = arr.length; j < jj; ++j) {

[32252] Fix | Delete

if (arr[j] !== value) {

[32253] Fix | Delete

return j;

[32254] Fix | Delete

}

[32255] Fix | Delete

}

[32256] Fix | Delete

return j;

[32257] Fix | Delete

}

[32258] Fix | Delete

function setValues(arr, start, end, value) {

[32259] Fix | Delete

for (let j = start; j < end; ++j) {

[32260] Fix | Delete

arr[j] = value;

[32261] Fix | Delete

}

[32262] Fix | Delete

}

[32263] Fix | Delete

function reverseValues(arr, start, end) {

[32264] Fix | Delete

for (let i = start, j = end - 1; i < j; ++i, --j) {

[32265] Fix | Delete

const temp = arr[i];

[32266] Fix | Delete

arr[i] = arr[j];

[32267] Fix | Delete

arr[j] = temp;

[32268] Fix | Delete

}

[32269] Fix | Delete

}

[32270] Fix | Delete

function createBidiText(str, isLTR, vertical = false) {

[32271] Fix | Delete

let dir = "ltr";

[32272] Fix | Delete

if (vertical) {

[32273] Fix | Delete

dir = "ttb";

[32274] Fix | Delete

} else if (!isLTR) {

[32275] Fix | Delete

dir = "rtl";

[32276] Fix | Delete

}

[32277] Fix | Delete

return {

[32278] Fix | Delete

str,

[32279] Fix | Delete

dir

[32280] Fix | Delete

};

[32281] Fix | Delete

}

[32282] Fix | Delete

const chars = [];

[32283] Fix | Delete

const types = [];

[32284] Fix | Delete

function bidi(str, startLevel = -1, vertical = false) {

[32285] Fix | Delete

let isLTR = true;

[32286] Fix | Delete

const strLength = str.length;

[32287] Fix | Delete

if (strLength === 0 || vertical) {

[32288] Fix | Delete

return createBidiText(str, isLTR, vertical);

[32289] Fix | Delete

}

[32290] Fix | Delete

chars.length = strLength;

[32291] Fix | Delete

types.length = strLength;

[32292] Fix | Delete

let numBidi = 0;

[32293] Fix | Delete

let i, ii;

[32294] Fix | Delete

for (i = 0; i < strLength; ++i) {

[32295] Fix | Delete

chars[i] = str.charAt(i);

[32296] Fix | Delete

const charCode = str.charCodeAt(i);

[32297] Fix | Delete

let charType = "L";

[32298] Fix | Delete

if (charCode <= 0x00ff) {

[32299] Fix | Delete

charType = baseTypes[charCode];

[32300] Fix | Delete

} else if (0x0590 <= charCode && charCode <= 0x05f4) {

[32301] Fix | Delete

charType = "R";

[32302] Fix | Delete

} else if (0x0600 <= charCode && charCode <= 0x06ff) {

[32303] Fix | Delete

charType = arabicTypes[charCode & 0xff];

[32304] Fix | Delete

if (!charType) {

[32305] Fix | Delete

warn("Bidi: invalid Unicode character " + charCode.toString(16));

[32306] Fix | Delete

}

[32307] Fix | Delete

} else if (0x0700 <= charCode && charCode <= 0x08ac || 0xfb50 <= charCode && charCode <= 0xfdff || 0xfe70 <= charCode && charCode <= 0xfeff) {

[32308] Fix | Delete

charType = "AL";

[32309] Fix | Delete

}

[32310] Fix | Delete

if (charType === "R" || charType === "AL" || charType === "AN") {

[32311] Fix | Delete

numBidi++;

[32312] Fix | Delete

}

[32313] Fix | Delete

types[i] = charType;

[32314] Fix | Delete

}

[32315] Fix | Delete

if (numBidi === 0) {

[32316] Fix | Delete

isLTR = true;

[32317] Fix | Delete

return createBidiText(str, isLTR);

[32318] Fix | Delete

}

[32319] Fix | Delete

if (startLevel === -1) {

[32320] Fix | Delete

if (numBidi / strLength < 0.3 && strLength > 4) {

[32321] Fix | Delete

isLTR = true;

[32322] Fix | Delete

startLevel = 0;

[32323] Fix | Delete

} else {

[32324] Fix | Delete

isLTR = false;

[32325] Fix | Delete

startLevel = 1;

[32326] Fix | Delete

}

[32327] Fix | Delete

}

[32328] Fix | Delete

const levels = [];

[32329] Fix | Delete

for (i = 0; i < strLength; ++i) {

[32330] Fix | Delete

levels[i] = startLevel;

[32331] Fix | Delete

}

[32332] Fix | Delete

const e = isOdd(startLevel) ? "R" : "L";

[32333] Fix | Delete

const sor = e;

[32334] Fix | Delete

const eor = sor;

[32335] Fix | Delete

let lastType = sor;

[32336] Fix | Delete

for (i = 0; i < strLength; ++i) {

[32337] Fix | Delete

if (types[i] === "NSM") {

[32338] Fix | Delete

types[i] = lastType;

[32339] Fix | Delete

} else {

[32340] Fix | Delete

lastType = types[i];

[32341] Fix | Delete

}

[32342] Fix | Delete

}

[32343] Fix | Delete

lastType = sor;

[32344] Fix | Delete

let t;

[32345] Fix | Delete

for (i = 0; i < strLength; ++i) {

[32346] Fix | Delete

t = types[i];

[32347] Fix | Delete

if (t === "EN") {

[32348] Fix | Delete

types[i] = lastType === "AL" ? "AN" : "EN";

[32349] Fix | Delete

} else if (t === "R" || t === "L" || t === "AL") {

[32350] Fix | Delete

lastType = t;

[32351] Fix | Delete

}

[32352] Fix | Delete

}

[32353] Fix | Delete

for (i = 0; i < strLength; ++i) {

[32354] Fix | Delete

t = types[i];

[32355] Fix | Delete

if (t === "AL") {

[32356] Fix | Delete

types[i] = "R";

[32357] Fix | Delete

}

[32358] Fix | Delete

}

[32359] Fix | Delete

for (i = 1; i < strLength - 1; ++i) {

[32360] Fix | Delete

if (types[i] === "ES" && types[i - 1] === "EN" && types[i + 1] === "EN") {

[32361] Fix | Delete

types[i] = "EN";

[32362] Fix | Delete

}

[32363] Fix | Delete

if (types[i] === "CS" && (types[i - 1] === "EN" || types[i - 1] === "AN") && types[i + 1] === types[i - 1]) {

[32364] Fix | Delete

types[i] = types[i - 1];

[32365] Fix | Delete

}

[32366] Fix | Delete

}

[32367] Fix | Delete

for (i = 0; i < strLength; ++i) {

[32368] Fix | Delete

if (types[i] === "EN") {

[32369] Fix | Delete

for (let j = i - 1; j >= 0; --j) {

[32370] Fix | Delete

if (types[j] !== "ET") {

[32371] Fix | Delete

break;

[32372] Fix | Delete

}

[32373] Fix | Delete

types[j] = "EN";

[32374] Fix | Delete

}

[32375] Fix | Delete

for (let j = i + 1; j < strLength; ++j) {

[32376] Fix | Delete

if (types[j] !== "ET") {

[32377] Fix | Delete

break;

[32378] Fix | Delete

}

[32379] Fix | Delete

types[j] = "EN";

[32380] Fix | Delete

}

[32381] Fix | Delete

}

[32382] Fix | Delete

}

[32383] Fix | Delete

for (i = 0; i < strLength; ++i) {

[32384] Fix | Delete

t = types[i];

[32385] Fix | Delete

if (t === "WS" || t === "ES" || t === "ET" || t === "CS") {

[32386] Fix | Delete

types[i] = "ON";

[32387] Fix | Delete

}

[32388] Fix | Delete

}

[32389] Fix | Delete

lastType = sor;

[32390] Fix | Delete

for (i = 0; i < strLength; ++i) {

[32391] Fix | Delete

t = types[i];

[32392] Fix | Delete

if (t === "EN") {

[32393] Fix | Delete

types[i] = lastType === "L" ? "L" : "EN";

[32394] Fix | Delete

} else if (t === "R" || t === "L") {

[32395] Fix | Delete

lastType = t;

[32396] Fix | Delete

}

[32397] Fix | Delete

}

[32398] Fix | Delete

for (i = 0; i < strLength; ++i) {

[32399] Fix | Delete

if (types[i] === "ON") {

[32400] Fix | Delete

const end = findUnequal(types, i + 1, "ON");

[32401] Fix | Delete

let before = sor;

[32402] Fix | Delete

if (i > 0) {

[32403] Fix | Delete

before = types[i - 1];

[32404] Fix | Delete

}

[32405] Fix | Delete

let after = eor;

[32406] Fix | Delete

if (end + 1 < strLength) {

[32407] Fix | Delete

after = types[end + 1];

[32408] Fix | Delete

}

[32409] Fix | Delete

if (before !== "L") {

[32410] Fix | Delete

before = "R";

[32411] Fix | Delete

}

[32412] Fix | Delete

if (after !== "L") {

[32413] Fix | Delete

after = "R";

[32414] Fix | Delete

}

[32415] Fix | Delete

if (before === after) {

[32416] Fix | Delete

setValues(types, i, end, before);

[32417] Fix | Delete

}

[32418] Fix | Delete

i = end - 1;

[32419] Fix | Delete

}

[32420] Fix | Delete

}

[32421] Fix | Delete

for (i = 0; i < strLength; ++i) {

[32422] Fix | Delete

if (types[i] === "ON") {

[32423] Fix | Delete

types[i] = e;

[32424] Fix | Delete

}

[32425] Fix | Delete

}

[32426] Fix | Delete

for (i = 0; i < strLength; ++i) {

[32427] Fix | Delete

t = types[i];

[32428] Fix | Delete

if (isEven(levels[i])) {

[32429] Fix | Delete

if (t === "R") {

[32430] Fix | Delete

levels[i] += 1;

[32431] Fix | Delete

} else if (t === "AN" || t === "EN") {

[32432] Fix | Delete

levels[i] += 2;

[32433] Fix | Delete

}

[32434] Fix | Delete

} else if (t === "L" || t === "AN" || t === "EN") {

[32435] Fix | Delete

levels[i] += 1;

[32436] Fix | Delete

}

[32437] Fix | Delete

}

[32438] Fix | Delete

let highestLevel = -1;

[32439] Fix | Delete

let lowestOddLevel = 99;

[32440] Fix | Delete

let level;

[32441] Fix | Delete

for (i = 0, ii = levels.length; i < ii; ++i) {

[32442] Fix | Delete

level = levels[i];

[32443] Fix | Delete

if (highestLevel < level) {

[32444] Fix | Delete

highestLevel = level;

[32445] Fix | Delete

}

[32446] Fix | Delete

if (lowestOddLevel > level && isOdd(level)) {

[32447] Fix | Delete

lowestOddLevel = level;

[32448] Fix | Delete

}

[32449] Fix | Delete

}

[32450] Fix | Delete

for (level = highestLevel; level >= lowestOddLevel; --level) {

[32451] Fix | Delete

let start = -1;

[32452] Fix | Delete

for (i = 0, ii = levels.length; i < ii; ++i) {

[32453] Fix | Delete

if (levels[i] < level) {

[32454] Fix | Delete

if (start >= 0) {

[32455] Fix | Delete

reverseValues(chars, start, i);

[32456] Fix | Delete

start = -1;

[32457] Fix | Delete

}

[32458] Fix | Delete

} else if (start < 0) {

[32459] Fix | Delete

start = i;

[32460] Fix | Delete

}

[32461] Fix | Delete

}

[32462] Fix | Delete

if (start >= 0) {

[32463] Fix | Delete

reverseValues(chars, start, levels.length);

[32464] Fix | Delete

}

[32465] Fix | Delete

}

[32466] Fix | Delete

for (i = 0, ii = chars.length; i < ii; ++i) {

[32467] Fix | Delete

const ch = chars[i];

[32468] Fix | Delete

if (ch === "<" || ch === ">") {

[32469] Fix | Delete

chars[i] = "";

[32470] Fix | Delete

}

[32471] Fix | Delete

}

[32472] Fix | Delete

return createBidiText(chars.join(""), isLTR);

[32473] Fix | Delete

}

[32474] Fix | Delete

[32475] Fix | Delete

;// CONCATENATED MODULE: ./src/core/font_substitutions.js

[32476] Fix | Delete

[32477] Fix | Delete

[32478] Fix | Delete

[32479] Fix | Delete

[32480] Fix | Delete

[32481] Fix | Delete

[32482] Fix | Delete

[32483] Fix | Delete

[32484] Fix | Delete

[32485] Fix | Delete

[32486] Fix | Delete

[32487] Fix | Delete

[32488] Fix | Delete

[32489] Fix | Delete

const NORMAL = {

[32490] Fix | Delete

style: "normal",

[32491] Fix | Delete

weight: "normal"

[32492] Fix | Delete

};

[32493] Fix | Delete

const BOLD = {

[32494] Fix | Delete

style: "normal",

[32495] Fix | Delete

weight: "bold"

[32496] Fix | Delete

};

[32497] Fix | Delete

const ITALIC = {

[32498] Fix | Delete

style: "italic",

[32499] Fix | Delete