1731 lines
69 KiB
Plaintext
1731 lines
69 KiB
Plaintext
// ../../node_modules/troika-worker-utils/dist/troika-worker-utils.esm.js
|
|
function workerBootstrap() {
|
|
var modules = /* @__PURE__ */ Object.create(null);
|
|
function registerModule(ref, callback) {
|
|
var id = ref.id;
|
|
var name = ref.name;
|
|
var dependencies = ref.dependencies;
|
|
if (dependencies === void 0) dependencies = [];
|
|
var init = ref.init;
|
|
if (init === void 0) init = function() {
|
|
};
|
|
var getTransferables = ref.getTransferables;
|
|
if (getTransferables === void 0) getTransferables = null;
|
|
if (modules[id]) {
|
|
return;
|
|
}
|
|
try {
|
|
dependencies = dependencies.map(function(dep) {
|
|
if (dep && dep.isWorkerModule) {
|
|
registerModule(dep, function(depResult) {
|
|
if (depResult instanceof Error) {
|
|
throw depResult;
|
|
}
|
|
});
|
|
dep = modules[dep.id].value;
|
|
}
|
|
return dep;
|
|
});
|
|
init = rehydrate("<" + name + ">.init", init);
|
|
if (getTransferables) {
|
|
getTransferables = rehydrate("<" + name + ">.getTransferables", getTransferables);
|
|
}
|
|
var value = null;
|
|
if (typeof init === "function") {
|
|
value = init.apply(void 0, dependencies);
|
|
} else {
|
|
console.error("worker module init function failed to rehydrate");
|
|
}
|
|
modules[id] = {
|
|
id,
|
|
value,
|
|
getTransferables
|
|
};
|
|
callback(value);
|
|
} catch (err) {
|
|
if (!(err && err.noLog)) {
|
|
console.error(err);
|
|
}
|
|
callback(err);
|
|
}
|
|
}
|
|
function callModule(ref, callback) {
|
|
var ref$1;
|
|
var id = ref.id;
|
|
var args = ref.args;
|
|
if (!modules[id] || typeof modules[id].value !== "function") {
|
|
callback(new Error("Worker module " + id + ": not found or its 'init' did not return a function"));
|
|
}
|
|
try {
|
|
var result = (ref$1 = modules[id]).value.apply(ref$1, args);
|
|
if (result && typeof result.then === "function") {
|
|
result.then(handleResult, function(rej) {
|
|
return callback(rej instanceof Error ? rej : new Error("" + rej));
|
|
});
|
|
} else {
|
|
handleResult(result);
|
|
}
|
|
} catch (err) {
|
|
callback(err);
|
|
}
|
|
function handleResult(result2) {
|
|
try {
|
|
var tx = modules[id].getTransferables && modules[id].getTransferables(result2);
|
|
if (!tx || !Array.isArray(tx) || !tx.length) {
|
|
tx = void 0;
|
|
}
|
|
callback(result2, tx);
|
|
} catch (err) {
|
|
console.error(err);
|
|
callback(err);
|
|
}
|
|
}
|
|
}
|
|
function rehydrate(name, str) {
|
|
var result = void 0;
|
|
self.troikaDefine = function(r) {
|
|
return result = r;
|
|
};
|
|
var url = URL.createObjectURL(
|
|
new Blob(
|
|
["/** " + name.replace(/\*/g, "") + " **/\n\ntroikaDefine(\n" + str + "\n)"],
|
|
{ type: "application/javascript" }
|
|
)
|
|
);
|
|
try {
|
|
importScripts(url);
|
|
} catch (err) {
|
|
console.error(err);
|
|
}
|
|
URL.revokeObjectURL(url);
|
|
delete self.troikaDefine;
|
|
return result;
|
|
}
|
|
self.addEventListener("message", function(e) {
|
|
var ref = e.data;
|
|
var messageId = ref.messageId;
|
|
var action = ref.action;
|
|
var data = ref.data;
|
|
try {
|
|
if (action === "registerModule") {
|
|
registerModule(data, function(result) {
|
|
if (result instanceof Error) {
|
|
postMessage({
|
|
messageId,
|
|
success: false,
|
|
error: result.message
|
|
});
|
|
} else {
|
|
postMessage({
|
|
messageId,
|
|
success: true,
|
|
result: { isCallable: typeof result === "function" }
|
|
});
|
|
}
|
|
});
|
|
}
|
|
if (action === "callModule") {
|
|
callModule(data, function(result, transferables) {
|
|
if (result instanceof Error) {
|
|
postMessage({
|
|
messageId,
|
|
success: false,
|
|
error: result.message
|
|
});
|
|
} else {
|
|
postMessage({
|
|
messageId,
|
|
success: true,
|
|
result
|
|
}, transferables || void 0);
|
|
}
|
|
});
|
|
}
|
|
} catch (err) {
|
|
postMessage({
|
|
messageId,
|
|
success: false,
|
|
error: err.stack
|
|
});
|
|
}
|
|
});
|
|
}
|
|
function defineMainThreadModule(options) {
|
|
var moduleFunc = function() {
|
|
var args = [], len = arguments.length;
|
|
while (len--) args[len] = arguments[len];
|
|
return moduleFunc._getInitResult().then(function(initResult) {
|
|
if (typeof initResult === "function") {
|
|
return initResult.apply(void 0, args);
|
|
} else {
|
|
throw new Error("Worker module function was called but `init` did not return a callable function");
|
|
}
|
|
});
|
|
};
|
|
moduleFunc._getInitResult = function() {
|
|
var dependencies = options.dependencies;
|
|
var init = options.init;
|
|
dependencies = Array.isArray(dependencies) ? dependencies.map(function(dep) {
|
|
if (dep) {
|
|
dep = dep.onMainThread || dep;
|
|
if (dep._getInitResult) {
|
|
dep = dep._getInitResult();
|
|
}
|
|
}
|
|
return dep;
|
|
}) : [];
|
|
var initPromise = Promise.all(dependencies).then(function(deps) {
|
|
return init.apply(null, deps);
|
|
});
|
|
moduleFunc._getInitResult = function() {
|
|
return initPromise;
|
|
};
|
|
return initPromise;
|
|
};
|
|
return moduleFunc;
|
|
}
|
|
var supportsWorkers = function() {
|
|
var supported = false;
|
|
if (typeof window !== "undefined" && typeof window.document !== "undefined") {
|
|
try {
|
|
var worker = new Worker(
|
|
URL.createObjectURL(new Blob([""], { type: "application/javascript" }))
|
|
);
|
|
worker.terminate();
|
|
supported = true;
|
|
} catch (err) {
|
|
if (typeof process !== "undefined" && false) ;
|
|
else {
|
|
console.log(
|
|
"Troika createWorkerModule: web workers not allowed; falling back to main thread execution. Cause: [" + err.message + "]"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
supportsWorkers = function() {
|
|
return supported;
|
|
};
|
|
return supported;
|
|
};
|
|
var _workerModuleId = 0;
|
|
var _messageId = 0;
|
|
var _allowInitAsString = false;
|
|
var workers = /* @__PURE__ */ Object.create(null);
|
|
var registeredModules = /* @__PURE__ */ Object.create(null);
|
|
var openRequests = /* @__PURE__ */ Object.create(null);
|
|
function defineWorkerModule(options) {
|
|
if ((!options || typeof options.init !== "function") && !_allowInitAsString) {
|
|
throw new Error("requires `options.init` function");
|
|
}
|
|
var dependencies = options.dependencies;
|
|
var init = options.init;
|
|
var getTransferables = options.getTransferables;
|
|
var workerId = options.workerId;
|
|
var onMainThread = defineMainThreadModule(options);
|
|
if (workerId == null) {
|
|
workerId = "#default";
|
|
}
|
|
var id = "workerModule" + ++_workerModuleId;
|
|
var name = options.name || id;
|
|
var registrationPromise = null;
|
|
dependencies = dependencies && dependencies.map(function(dep) {
|
|
if (typeof dep === "function" && !dep.workerModuleData) {
|
|
_allowInitAsString = true;
|
|
dep = defineWorkerModule({
|
|
workerId,
|
|
name: "<" + name + "> function dependency: " + dep.name,
|
|
init: "function(){return (\n" + stringifyFunction(dep) + "\n)}"
|
|
});
|
|
_allowInitAsString = false;
|
|
}
|
|
if (dep && dep.workerModuleData) {
|
|
dep = dep.workerModuleData;
|
|
}
|
|
return dep;
|
|
});
|
|
function moduleFunc() {
|
|
var args = [], len = arguments.length;
|
|
while (len--) args[len] = arguments[len];
|
|
if (!supportsWorkers()) {
|
|
return onMainThread.apply(void 0, args);
|
|
}
|
|
if (!registrationPromise) {
|
|
registrationPromise = callWorker(workerId, "registerModule", moduleFunc.workerModuleData);
|
|
var unregister = function() {
|
|
registrationPromise = null;
|
|
registeredModules[workerId].delete(unregister);
|
|
};
|
|
(registeredModules[workerId] || (registeredModules[workerId] = /* @__PURE__ */ new Set())).add(unregister);
|
|
}
|
|
return registrationPromise.then(function(ref) {
|
|
var isCallable = ref.isCallable;
|
|
if (isCallable) {
|
|
return callWorker(workerId, "callModule", { id, args });
|
|
} else {
|
|
throw new Error("Worker module function was called but `init` did not return a callable function");
|
|
}
|
|
});
|
|
}
|
|
moduleFunc.workerModuleData = {
|
|
isWorkerModule: true,
|
|
id,
|
|
name,
|
|
dependencies,
|
|
init: stringifyFunction(init),
|
|
getTransferables: getTransferables && stringifyFunction(getTransferables)
|
|
};
|
|
moduleFunc.onMainThread = onMainThread;
|
|
return moduleFunc;
|
|
}
|
|
function terminateWorker(workerId) {
|
|
if (registeredModules[workerId]) {
|
|
registeredModules[workerId].forEach(function(unregister) {
|
|
unregister();
|
|
});
|
|
}
|
|
if (workers[workerId]) {
|
|
workers[workerId].terminate();
|
|
delete workers[workerId];
|
|
}
|
|
}
|
|
function stringifyFunction(fn) {
|
|
var str = fn.toString();
|
|
if (!/^function/.test(str) && /^\w+\s*\(/.test(str)) {
|
|
str = "function " + str;
|
|
}
|
|
return str;
|
|
}
|
|
function getWorker(workerId) {
|
|
var worker = workers[workerId];
|
|
if (!worker) {
|
|
var bootstrap = stringifyFunction(workerBootstrap);
|
|
worker = workers[workerId] = new Worker(
|
|
URL.createObjectURL(
|
|
new Blob(
|
|
["/** Worker Module Bootstrap: " + workerId.replace(/\*/g, "") + " **/\n\n;(" + bootstrap + ")()"],
|
|
{ type: "application/javascript" }
|
|
)
|
|
)
|
|
);
|
|
worker.onmessage = function(e) {
|
|
var response = e.data;
|
|
var msgId = response.messageId;
|
|
var callback = openRequests[msgId];
|
|
if (!callback) {
|
|
throw new Error("WorkerModule response with empty or unknown messageId");
|
|
}
|
|
delete openRequests[msgId];
|
|
callback(response);
|
|
};
|
|
}
|
|
return worker;
|
|
}
|
|
function callWorker(workerId, action, data) {
|
|
return new Promise(function(resolve, reject) {
|
|
var messageId = ++_messageId;
|
|
openRequests[messageId] = function(response) {
|
|
if (response.success) {
|
|
resolve(response.result);
|
|
} else {
|
|
reject(new Error("Error in worker " + action + " call: " + response.error));
|
|
}
|
|
};
|
|
getWorker(workerId).postMessage({
|
|
messageId,
|
|
action,
|
|
data
|
|
});
|
|
});
|
|
}
|
|
|
|
// ../../node_modules/webgl-sdf-generator/dist/webgl-sdf-generator.mjs
|
|
function SDFGenerator() {
|
|
var exports = function(exports2) {
|
|
function pointOnQuadraticBezier(x0, y0, x1, y1, x2, y2, t, pointOut) {
|
|
var t2 = 1 - t;
|
|
pointOut.x = t2 * t2 * x0 + 2 * t2 * t * x1 + t * t * x2;
|
|
pointOut.y = t2 * t2 * y0 + 2 * t2 * t * y1 + t * t * y2;
|
|
}
|
|
function pointOnCubicBezier(x0, y0, x1, y1, x2, y2, x3, y3, t, pointOut) {
|
|
var t2 = 1 - t;
|
|
pointOut.x = t2 * t2 * t2 * x0 + 3 * t2 * t2 * t * x1 + 3 * t2 * t * t * x2 + t * t * t * x3;
|
|
pointOut.y = t2 * t2 * t2 * y0 + 3 * t2 * t2 * t * y1 + 3 * t2 * t * t * y2 + t * t * t * y3;
|
|
}
|
|
function forEachPathCommand(pathString, commandCallback) {
|
|
var segmentRE = /([MLQCZ])([^MLQCZ]*)/g;
|
|
var match, firstX, firstY, prevX, prevY;
|
|
while (match = segmentRE.exec(pathString)) {
|
|
var args = match[2].replace(/^\s*|\s*$/g, "").split(/[,\s]+/).map(function(v) {
|
|
return parseFloat(v);
|
|
});
|
|
switch (match[1]) {
|
|
case "M":
|
|
prevX = firstX = args[0];
|
|
prevY = firstY = args[1];
|
|
break;
|
|
case "L":
|
|
if (args[0] !== prevX || args[1] !== prevY) {
|
|
commandCallback("L", prevX, prevY, prevX = args[0], prevY = args[1]);
|
|
}
|
|
break;
|
|
case "Q": {
|
|
commandCallback("Q", prevX, prevY, prevX = args[2], prevY = args[3], args[0], args[1]);
|
|
break;
|
|
}
|
|
case "C": {
|
|
commandCallback("C", prevX, prevY, prevX = args[4], prevY = args[5], args[0], args[1], args[2], args[3]);
|
|
break;
|
|
}
|
|
case "Z":
|
|
if (prevX !== firstX || prevY !== firstY) {
|
|
commandCallback("L", prevX, prevY, firstX, firstY);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function pathToLineSegments(pathString, segmentCallback, curvePoints) {
|
|
if (curvePoints === void 0) curvePoints = 16;
|
|
var tempPoint = { x: 0, y: 0 };
|
|
forEachPathCommand(pathString, function(command, startX, startY, endX, endY, ctrl1X, ctrl1Y, ctrl2X, ctrl2Y) {
|
|
switch (command) {
|
|
case "L":
|
|
segmentCallback(startX, startY, endX, endY);
|
|
break;
|
|
case "Q": {
|
|
var prevCurveX = startX;
|
|
var prevCurveY = startY;
|
|
for (var i = 1; i < curvePoints; i++) {
|
|
pointOnQuadraticBezier(
|
|
startX,
|
|
startY,
|
|
ctrl1X,
|
|
ctrl1Y,
|
|
endX,
|
|
endY,
|
|
i / (curvePoints - 1),
|
|
tempPoint
|
|
);
|
|
segmentCallback(prevCurveX, prevCurveY, tempPoint.x, tempPoint.y);
|
|
prevCurveX = tempPoint.x;
|
|
prevCurveY = tempPoint.y;
|
|
}
|
|
break;
|
|
}
|
|
case "C": {
|
|
var prevCurveX$1 = startX;
|
|
var prevCurveY$1 = startY;
|
|
for (var i$1 = 1; i$1 < curvePoints; i$1++) {
|
|
pointOnCubicBezier(
|
|
startX,
|
|
startY,
|
|
ctrl1X,
|
|
ctrl1Y,
|
|
ctrl2X,
|
|
ctrl2Y,
|
|
endX,
|
|
endY,
|
|
i$1 / (curvePoints - 1),
|
|
tempPoint
|
|
);
|
|
segmentCallback(prevCurveX$1, prevCurveY$1, tempPoint.x, tempPoint.y);
|
|
prevCurveX$1 = tempPoint.x;
|
|
prevCurveY$1 = tempPoint.y;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
var viewportQuadVertex = "precision highp float;attribute vec2 aUV;varying vec2 vUV;void main(){vUV=aUV;gl_Position=vec4(mix(vec2(-1.0),vec2(1.0),aUV),0.0,1.0);}";
|
|
var copyTexFragment = "precision highp float;uniform sampler2D tex;varying vec2 vUV;void main(){gl_FragColor=texture2D(tex,vUV);}";
|
|
var cache = /* @__PURE__ */ new WeakMap();
|
|
var glContextParams = {
|
|
premultipliedAlpha: false,
|
|
preserveDrawingBuffer: true,
|
|
antialias: false,
|
|
depth: false
|
|
};
|
|
function withWebGLContext(glOrCanvas, callback) {
|
|
var gl = glOrCanvas.getContext ? glOrCanvas.getContext("webgl", glContextParams) : glOrCanvas;
|
|
var wrapper = cache.get(gl);
|
|
if (!wrapper) {
|
|
let getExtension = function(name) {
|
|
var ext = extensions[name];
|
|
if (!ext) {
|
|
ext = extensions[name] = gl.getExtension(name);
|
|
if (!ext) {
|
|
throw new Error(name + " not supported");
|
|
}
|
|
}
|
|
return ext;
|
|
}, compileShader = function(src, type) {
|
|
var shader = gl.createShader(type);
|
|
gl.shaderSource(shader, src);
|
|
gl.compileShader(shader);
|
|
return shader;
|
|
}, withProgram = function(name, vert, frag, func) {
|
|
if (!programs[name]) {
|
|
var attributes = {};
|
|
var uniforms = {};
|
|
var program = gl.createProgram();
|
|
gl.attachShader(program, compileShader(vert, gl.VERTEX_SHADER));
|
|
gl.attachShader(program, compileShader(frag, gl.FRAGMENT_SHADER));
|
|
gl.linkProgram(program);
|
|
programs[name] = {
|
|
program,
|
|
transaction: function transaction(func2) {
|
|
gl.useProgram(program);
|
|
func2({
|
|
setUniform: function setUniform(type, name2) {
|
|
var values = [], len = arguments.length - 2;
|
|
while (len-- > 0) values[len] = arguments[len + 2];
|
|
var uniformLoc = uniforms[name2] || (uniforms[name2] = gl.getUniformLocation(program, name2));
|
|
gl["uniform" + type].apply(gl, [uniformLoc].concat(values));
|
|
},
|
|
setAttribute: function setAttribute(name2, size, usage, instancingDivisor, data) {
|
|
var attr = attributes[name2];
|
|
if (!attr) {
|
|
attr = attributes[name2] = {
|
|
buf: gl.createBuffer(),
|
|
// TODO should we destroy our buffers?
|
|
loc: gl.getAttribLocation(program, name2),
|
|
data: null
|
|
};
|
|
}
|
|
gl.bindBuffer(gl.ARRAY_BUFFER, attr.buf);
|
|
gl.vertexAttribPointer(attr.loc, size, gl.FLOAT, false, 0, 0);
|
|
gl.enableVertexAttribArray(attr.loc);
|
|
if (isWebGL2) {
|
|
gl.vertexAttribDivisor(attr.loc, instancingDivisor);
|
|
} else {
|
|
getExtension("ANGLE_instanced_arrays").vertexAttribDivisorANGLE(attr.loc, instancingDivisor);
|
|
}
|
|
if (data !== attr.data) {
|
|
gl.bufferData(gl.ARRAY_BUFFER, data, usage);
|
|
attr.data = data;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
}
|
|
programs[name].transaction(func);
|
|
}, withTexture = function(name, func) {
|
|
textureUnit++;
|
|
try {
|
|
gl.activeTexture(gl.TEXTURE0 + textureUnit);
|
|
var texture = textures[name];
|
|
if (!texture) {
|
|
texture = textures[name] = gl.createTexture();
|
|
gl.bindTexture(gl.TEXTURE_2D, texture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
}
|
|
gl.bindTexture(gl.TEXTURE_2D, texture);
|
|
func(texture, textureUnit);
|
|
} finally {
|
|
textureUnit--;
|
|
}
|
|
}, withTextureFramebuffer = function(texture, textureUnit2, func) {
|
|
var framebuffer = gl.createFramebuffer();
|
|
framebufferStack.push(framebuffer);
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
|
|
gl.activeTexture(gl.TEXTURE0 + textureUnit2);
|
|
gl.bindTexture(gl.TEXTURE_2D, texture);
|
|
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
|
|
try {
|
|
func(framebuffer);
|
|
} finally {
|
|
gl.deleteFramebuffer(framebuffer);
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, framebufferStack[--framebufferStack.length - 1] || null);
|
|
}
|
|
}, handleContextLoss = function() {
|
|
extensions = {};
|
|
programs = {};
|
|
textures = {};
|
|
textureUnit = -1;
|
|
framebufferStack.length = 0;
|
|
};
|
|
var isWebGL2 = typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext;
|
|
var extensions = {};
|
|
var programs = {};
|
|
var textures = {};
|
|
var textureUnit = -1;
|
|
var framebufferStack = [];
|
|
gl.canvas.addEventListener("webglcontextlost", function(e) {
|
|
handleContextLoss();
|
|
e.preventDefault();
|
|
}, false);
|
|
cache.set(gl, wrapper = {
|
|
gl,
|
|
isWebGL2,
|
|
getExtension,
|
|
withProgram,
|
|
withTexture,
|
|
withTextureFramebuffer,
|
|
handleContextLoss
|
|
});
|
|
}
|
|
callback(wrapper);
|
|
}
|
|
function renderImageData(glOrCanvas, imageData, x, y, width, height, channels, framebuffer) {
|
|
if (channels === void 0) channels = 15;
|
|
if (framebuffer === void 0) framebuffer = null;
|
|
withWebGLContext(glOrCanvas, function(ref) {
|
|
var gl = ref.gl;
|
|
var withProgram = ref.withProgram;
|
|
var withTexture = ref.withTexture;
|
|
withTexture("copy", function(tex, texUnit) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, imageData);
|
|
withProgram("copy", viewportQuadVertex, copyTexFragment, function(ref2) {
|
|
var setUniform = ref2.setUniform;
|
|
var setAttribute = ref2.setAttribute;
|
|
setAttribute("aUV", 2, gl.STATIC_DRAW, 0, new Float32Array([0, 0, 2, 0, 0, 2]));
|
|
setUniform("1i", "image", texUnit);
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer || null);
|
|
gl.disable(gl.BLEND);
|
|
gl.colorMask(channels & 8, channels & 4, channels & 2, channels & 1);
|
|
gl.viewport(x, y, width, height);
|
|
gl.scissor(x, y, width, height);
|
|
gl.drawArrays(gl.TRIANGLES, 0, 3);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
function resizeWebGLCanvasWithoutClearing(canvas, newWidth, newHeight) {
|
|
var width = canvas.width;
|
|
var height = canvas.height;
|
|
withWebGLContext(canvas, function(ref) {
|
|
var gl = ref.gl;
|
|
var data = new Uint8Array(width * height * 4);
|
|
gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, data);
|
|
canvas.width = newWidth;
|
|
canvas.height = newHeight;
|
|
renderImageData(gl, data, 0, 0, width, height);
|
|
});
|
|
}
|
|
var webglUtils = Object.freeze({
|
|
__proto__: null,
|
|
withWebGLContext,
|
|
renderImageData,
|
|
resizeWebGLCanvasWithoutClearing
|
|
});
|
|
function generate$2(sdfWidth, sdfHeight, path, viewBox, maxDistance, sdfExponent) {
|
|
if (sdfExponent === void 0) sdfExponent = 1;
|
|
var textureData = new Uint8Array(sdfWidth * sdfHeight);
|
|
var viewBoxWidth = viewBox[2] - viewBox[0];
|
|
var viewBoxHeight = viewBox[3] - viewBox[1];
|
|
var segments = [];
|
|
pathToLineSegments(path, function(x1, y1, x2, y2) {
|
|
segments.push({
|
|
x1,
|
|
y1,
|
|
x2,
|
|
y2,
|
|
minX: Math.min(x1, x2),
|
|
minY: Math.min(y1, y2),
|
|
maxX: Math.max(x1, x2),
|
|
maxY: Math.max(y1, y2)
|
|
});
|
|
});
|
|
segments.sort(function(a, b) {
|
|
return a.maxX - b.maxX;
|
|
});
|
|
for (var sdfX = 0; sdfX < sdfWidth; sdfX++) {
|
|
for (var sdfY = 0; sdfY < sdfHeight; sdfY++) {
|
|
var signedDist = findNearestSignedDistance(
|
|
viewBox[0] + viewBoxWidth * (sdfX + 0.5) / sdfWidth,
|
|
viewBox[1] + viewBoxHeight * (sdfY + 0.5) / sdfHeight
|
|
);
|
|
var alpha = Math.pow(1 - Math.abs(signedDist) / maxDistance, sdfExponent) / 2;
|
|
if (signedDist < 0) {
|
|
alpha = 1 - alpha;
|
|
}
|
|
alpha = Math.max(0, Math.min(255, Math.round(alpha * 255)));
|
|
textureData[sdfY * sdfWidth + sdfX] = alpha;
|
|
}
|
|
}
|
|
return textureData;
|
|
function findNearestSignedDistance(x, y) {
|
|
var closestDistSq = Infinity;
|
|
var closestDist = Infinity;
|
|
for (var i = segments.length; i--; ) {
|
|
var seg = segments[i];
|
|
if (seg.maxX + closestDist <= x) {
|
|
break;
|
|
}
|
|
if (x + closestDist > seg.minX && y - closestDist < seg.maxY && y + closestDist > seg.minY) {
|
|
var distSq = absSquareDistanceToLineSegment(x, y, seg.x1, seg.y1, seg.x2, seg.y2);
|
|
if (distSq < closestDistSq) {
|
|
closestDistSq = distSq;
|
|
closestDist = Math.sqrt(closestDistSq);
|
|
}
|
|
}
|
|
}
|
|
if (isPointInPoly(x, y)) {
|
|
closestDist = -closestDist;
|
|
}
|
|
return closestDist;
|
|
}
|
|
function isPointInPoly(x, y) {
|
|
var winding = 0;
|
|
for (var i = segments.length; i--; ) {
|
|
var seg = segments[i];
|
|
if (seg.maxX <= x) {
|
|
break;
|
|
}
|
|
var intersects = seg.y1 > y !== seg.y2 > y && x < (seg.x2 - seg.x1) * (y - seg.y1) / (seg.y2 - seg.y1) + seg.x1;
|
|
if (intersects) {
|
|
winding += seg.y1 < seg.y2 ? 1 : -1;
|
|
}
|
|
}
|
|
return winding !== 0;
|
|
}
|
|
}
|
|
function generateIntoCanvas$2(sdfWidth, sdfHeight, path, viewBox, maxDistance, sdfExponent, canvas, x, y, channel) {
|
|
if (sdfExponent === void 0) sdfExponent = 1;
|
|
if (x === void 0) x = 0;
|
|
if (y === void 0) y = 0;
|
|
if (channel === void 0) channel = 0;
|
|
generateIntoFramebuffer$1(sdfWidth, sdfHeight, path, viewBox, maxDistance, sdfExponent, canvas, null, x, y, channel);
|
|
}
|
|
function generateIntoFramebuffer$1(sdfWidth, sdfHeight, path, viewBox, maxDistance, sdfExponent, glOrCanvas, framebuffer, x, y, channel) {
|
|
if (sdfExponent === void 0) sdfExponent = 1;
|
|
if (x === void 0) x = 0;
|
|
if (y === void 0) y = 0;
|
|
if (channel === void 0) channel = 0;
|
|
var data = generate$2(sdfWidth, sdfHeight, path, viewBox, maxDistance, sdfExponent);
|
|
var rgbaData = new Uint8Array(data.length * 4);
|
|
for (var i = 0; i < data.length; i++) {
|
|
rgbaData[i * 4 + channel] = data[i];
|
|
}
|
|
renderImageData(glOrCanvas, rgbaData, x, y, sdfWidth, sdfHeight, 1 << 3 - channel, framebuffer);
|
|
}
|
|
function absSquareDistanceToLineSegment(x, y, lineX0, lineY0, lineX1, lineY1) {
|
|
var ldx = lineX1 - lineX0;
|
|
var ldy = lineY1 - lineY0;
|
|
var lengthSq = ldx * ldx + ldy * ldy;
|
|
var t = lengthSq ? Math.max(0, Math.min(1, ((x - lineX0) * ldx + (y - lineY0) * ldy) / lengthSq)) : 0;
|
|
var dx = x - (lineX0 + t * ldx);
|
|
var dy = y - (lineY0 + t * ldy);
|
|
return dx * dx + dy * dy;
|
|
}
|
|
var javascript = Object.freeze({
|
|
__proto__: null,
|
|
generate: generate$2,
|
|
generateIntoCanvas: generateIntoCanvas$2,
|
|
generateIntoFramebuffer: generateIntoFramebuffer$1
|
|
});
|
|
var mainVertex = "precision highp float;uniform vec4 uGlyphBounds;attribute vec2 aUV;attribute vec4 aLineSegment;varying vec4 vLineSegment;varying vec2 vGlyphXY;void main(){vLineSegment=aLineSegment;vGlyphXY=mix(uGlyphBounds.xy,uGlyphBounds.zw,aUV);gl_Position=vec4(mix(vec2(-1.0),vec2(1.0),aUV),0.0,1.0);}";
|
|
var mainFragment = "precision highp float;uniform vec4 uGlyphBounds;uniform float uMaxDistance;uniform float uExponent;varying vec4 vLineSegment;varying vec2 vGlyphXY;float absDistToSegment(vec2 point,vec2 lineA,vec2 lineB){vec2 lineDir=lineB-lineA;float lenSq=dot(lineDir,lineDir);float t=lenSq==0.0 ? 0.0 : clamp(dot(point-lineA,lineDir)/lenSq,0.0,1.0);vec2 linePt=lineA+t*lineDir;return distance(point,linePt);}void main(){vec4 seg=vLineSegment;vec2 p=vGlyphXY;float dist=absDistToSegment(p,seg.xy,seg.zw);float val=pow(1.0-clamp(dist/uMaxDistance,0.0,1.0),uExponent)*0.5;bool crossing=(seg.y>p.y!=seg.w>p.y)&&(p.x<(seg.z-seg.x)*(p.y-seg.y)/(seg.w-seg.y)+seg.x);bool crossingUp=crossing&&vLineSegment.y<vLineSegment.w;gl_FragColor=vec4(crossingUp ? 1.0/255.0 : 0.0,crossing&&!crossingUp ? 1.0/255.0 : 0.0,0.0,val);}";
|
|
var postFragment = "precision highp float;uniform sampler2D tex;varying vec2 vUV;void main(){vec4 color=texture2D(tex,vUV);bool inside=color.r!=color.g;float val=inside ? 1.0-color.a : color.a;gl_FragColor=vec4(val);}";
|
|
var viewportUVs = new Float32Array([0, 0, 2, 0, 0, 2]);
|
|
var implicitContext = null;
|
|
var isTestingSupport = false;
|
|
var NULL_OBJECT = {};
|
|
var supportByCanvas = /* @__PURE__ */ new WeakMap();
|
|
function validateSupport(glOrCanvas) {
|
|
if (!isTestingSupport && !isSupported(glOrCanvas)) {
|
|
throw new Error("WebGL generation not supported");
|
|
}
|
|
}
|
|
function generate$1(sdfWidth, sdfHeight, path, viewBox, maxDistance, sdfExponent, glOrCanvas) {
|
|
if (sdfExponent === void 0) sdfExponent = 1;
|
|
if (glOrCanvas === void 0) glOrCanvas = null;
|
|
if (!glOrCanvas) {
|
|
glOrCanvas = implicitContext;
|
|
if (!glOrCanvas) {
|
|
var canvas = typeof OffscreenCanvas === "function" ? new OffscreenCanvas(1, 1) : typeof document !== "undefined" ? document.createElement("canvas") : null;
|
|
if (!canvas) {
|
|
throw new Error("OffscreenCanvas or DOM canvas not supported");
|
|
}
|
|
glOrCanvas = implicitContext = canvas.getContext("webgl", { depth: false });
|
|
}
|
|
}
|
|
validateSupport(glOrCanvas);
|
|
var rgbaData = new Uint8Array(sdfWidth * sdfHeight * 4);
|
|
withWebGLContext(glOrCanvas, function(ref) {
|
|
var gl = ref.gl;
|
|
var withTexture = ref.withTexture;
|
|
var withTextureFramebuffer = ref.withTextureFramebuffer;
|
|
withTexture("readable", function(texture, textureUnit) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, sdfWidth, sdfHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
|
|
withTextureFramebuffer(texture, textureUnit, function(framebuffer) {
|
|
generateIntoFramebuffer(
|
|
sdfWidth,
|
|
sdfHeight,
|
|
path,
|
|
viewBox,
|
|
maxDistance,
|
|
sdfExponent,
|
|
gl,
|
|
framebuffer,
|
|
0,
|
|
0,
|
|
0
|
|
// red channel
|
|
);
|
|
gl.readPixels(0, 0, sdfWidth, sdfHeight, gl.RGBA, gl.UNSIGNED_BYTE, rgbaData);
|
|
});
|
|
});
|
|
});
|
|
var data = new Uint8Array(sdfWidth * sdfHeight);
|
|
for (var i = 0, j = 0; i < rgbaData.length; i += 4) {
|
|
data[j++] = rgbaData[i];
|
|
}
|
|
return data;
|
|
}
|
|
function generateIntoCanvas$1(sdfWidth, sdfHeight, path, viewBox, maxDistance, sdfExponent, canvas, x, y, channel) {
|
|
if (sdfExponent === void 0) sdfExponent = 1;
|
|
if (x === void 0) x = 0;
|
|
if (y === void 0) y = 0;
|
|
if (channel === void 0) channel = 0;
|
|
generateIntoFramebuffer(sdfWidth, sdfHeight, path, viewBox, maxDistance, sdfExponent, canvas, null, x, y, channel);
|
|
}
|
|
function generateIntoFramebuffer(sdfWidth, sdfHeight, path, viewBox, maxDistance, sdfExponent, glOrCanvas, framebuffer, x, y, channel) {
|
|
if (sdfExponent === void 0) sdfExponent = 1;
|
|
if (x === void 0) x = 0;
|
|
if (y === void 0) y = 0;
|
|
if (channel === void 0) channel = 0;
|
|
validateSupport(glOrCanvas);
|
|
var lineSegmentCoords = [];
|
|
pathToLineSegments(path, function(x1, y1, x2, y2) {
|
|
lineSegmentCoords.push(x1, y1, x2, y2);
|
|
});
|
|
lineSegmentCoords = new Float32Array(lineSegmentCoords);
|
|
withWebGLContext(glOrCanvas, function(ref) {
|
|
var gl = ref.gl;
|
|
var isWebGL2 = ref.isWebGL2;
|
|
var getExtension = ref.getExtension;
|
|
var withProgram = ref.withProgram;
|
|
var withTexture = ref.withTexture;
|
|
var withTextureFramebuffer = ref.withTextureFramebuffer;
|
|
var handleContextLoss = ref.handleContextLoss;
|
|
withTexture("rawDistances", function(intermediateTexture, intermediateTextureUnit) {
|
|
if (sdfWidth !== intermediateTexture._lastWidth || sdfHeight !== intermediateTexture._lastHeight) {
|
|
gl.texImage2D(
|
|
gl.TEXTURE_2D,
|
|
0,
|
|
gl.RGBA,
|
|
intermediateTexture._lastWidth = sdfWidth,
|
|
intermediateTexture._lastHeight = sdfHeight,
|
|
0,
|
|
gl.RGBA,
|
|
gl.UNSIGNED_BYTE,
|
|
null
|
|
);
|
|
}
|
|
withProgram("main", mainVertex, mainFragment, function(ref2) {
|
|
var setAttribute = ref2.setAttribute;
|
|
var setUniform = ref2.setUniform;
|
|
var instancingExtension = !isWebGL2 && getExtension("ANGLE_instanced_arrays");
|
|
var blendMinMaxExtension = !isWebGL2 && getExtension("EXT_blend_minmax");
|
|
setAttribute("aUV", 2, gl.STATIC_DRAW, 0, viewportUVs);
|
|
setAttribute("aLineSegment", 4, gl.DYNAMIC_DRAW, 1, lineSegmentCoords);
|
|
setUniform.apply(void 0, ["4f", "uGlyphBounds"].concat(viewBox));
|
|
setUniform("1f", "uMaxDistance", maxDistance);
|
|
setUniform("1f", "uExponent", sdfExponent);
|
|
withTextureFramebuffer(intermediateTexture, intermediateTextureUnit, function(framebuffer2) {
|
|
gl.enable(gl.BLEND);
|
|
gl.colorMask(true, true, true, true);
|
|
gl.viewport(0, 0, sdfWidth, sdfHeight);
|
|
gl.scissor(0, 0, sdfWidth, sdfHeight);
|
|
gl.blendFunc(gl.ONE, gl.ONE);
|
|
gl.blendEquationSeparate(gl.FUNC_ADD, isWebGL2 ? gl.MAX : blendMinMaxExtension.MAX_EXT);
|
|
gl.clear(gl.COLOR_BUFFER_BIT);
|
|
if (isWebGL2) {
|
|
gl.drawArraysInstanced(gl.TRIANGLES, 0, 3, lineSegmentCoords.length / 4);
|
|
} else {
|
|
instancingExtension.drawArraysInstancedANGLE(gl.TRIANGLES, 0, 3, lineSegmentCoords.length / 4);
|
|
}
|
|
});
|
|
});
|
|
withProgram("post", viewportQuadVertex, postFragment, function(program) {
|
|
program.setAttribute("aUV", 2, gl.STATIC_DRAW, 0, viewportUVs);
|
|
program.setUniform("1i", "tex", intermediateTextureUnit);
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
|
|
gl.disable(gl.BLEND);
|
|
gl.colorMask(channel === 0, channel === 1, channel === 2, channel === 3);
|
|
gl.viewport(x, y, sdfWidth, sdfHeight);
|
|
gl.scissor(x, y, sdfWidth, sdfHeight);
|
|
gl.drawArrays(gl.TRIANGLES, 0, 3);
|
|
});
|
|
});
|
|
if (gl.isContextLost()) {
|
|
handleContextLoss();
|
|
throw new Error("webgl context lost");
|
|
}
|
|
});
|
|
}
|
|
function isSupported(glOrCanvas) {
|
|
var key = !glOrCanvas || glOrCanvas === implicitContext ? NULL_OBJECT : glOrCanvas.canvas || glOrCanvas;
|
|
var supported = supportByCanvas.get(key);
|
|
if (supported === void 0) {
|
|
isTestingSupport = true;
|
|
var failReason = null;
|
|
try {
|
|
var expectedResult = [
|
|
97,
|
|
106,
|
|
97,
|
|
61,
|
|
99,
|
|
137,
|
|
118,
|
|
80,
|
|
80,
|
|
118,
|
|
137,
|
|
99,
|
|
61,
|
|
97,
|
|
106,
|
|
97
|
|
];
|
|
var testResult = generate$1(
|
|
4,
|
|
4,
|
|
"M8,8L16,8L24,24L16,24Z",
|
|
[0, 0, 32, 32],
|
|
24,
|
|
1,
|
|
glOrCanvas
|
|
);
|
|
supported = testResult && expectedResult.length === testResult.length && testResult.every(function(val, i) {
|
|
return val === expectedResult[i];
|
|
});
|
|
if (!supported) {
|
|
failReason = "bad trial run results";
|
|
console.info(expectedResult, testResult);
|
|
}
|
|
} catch (err) {
|
|
supported = false;
|
|
failReason = err.message;
|
|
}
|
|
if (failReason) {
|
|
console.warn("WebGL SDF generation not supported:", failReason);
|
|
}
|
|
isTestingSupport = false;
|
|
supportByCanvas.set(key, supported);
|
|
}
|
|
return supported;
|
|
}
|
|
var webgl = Object.freeze({
|
|
__proto__: null,
|
|
generate: generate$1,
|
|
generateIntoCanvas: generateIntoCanvas$1,
|
|
generateIntoFramebuffer,
|
|
isSupported
|
|
});
|
|
function generate(sdfWidth, sdfHeight, path, viewBox, maxDistance, sdfExponent) {
|
|
if (maxDistance === void 0) maxDistance = Math.max(viewBox[2] - viewBox[0], viewBox[3] - viewBox[1]) / 2;
|
|
if (sdfExponent === void 0) sdfExponent = 1;
|
|
try {
|
|
return generate$1.apply(webgl, arguments);
|
|
} catch (e) {
|
|
console.info("WebGL SDF generation failed, falling back to JS", e);
|
|
return generate$2.apply(javascript, arguments);
|
|
}
|
|
}
|
|
function generateIntoCanvas(sdfWidth, sdfHeight, path, viewBox, maxDistance, sdfExponent, canvas, x, y, channel) {
|
|
if (maxDistance === void 0) maxDistance = Math.max(viewBox[2] - viewBox[0], viewBox[3] - viewBox[1]) / 2;
|
|
if (sdfExponent === void 0) sdfExponent = 1;
|
|
if (x === void 0) x = 0;
|
|
if (y === void 0) y = 0;
|
|
if (channel === void 0) channel = 0;
|
|
try {
|
|
return generateIntoCanvas$1.apply(webgl, arguments);
|
|
} catch (e) {
|
|
console.info("WebGL SDF generation failed, falling back to JS", e);
|
|
return generateIntoCanvas$2.apply(javascript, arguments);
|
|
}
|
|
}
|
|
exports2.forEachPathCommand = forEachPathCommand;
|
|
exports2.generate = generate;
|
|
exports2.generateIntoCanvas = generateIntoCanvas;
|
|
exports2.javascript = javascript;
|
|
exports2.pathToLineSegments = pathToLineSegments;
|
|
exports2.webgl = webgl;
|
|
exports2.webglUtils = webglUtils;
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
return exports2;
|
|
}({});
|
|
return exports;
|
|
}
|
|
|
|
// ../../node_modules/bidi-js/dist/bidi.mjs
|
|
function bidiFactory() {
|
|
var bidi = function(exports) {
|
|
var DATA = {
|
|
"R": "13k,1a,2,3,3,2+1j,ch+16,a+1,5+2,2+n,5,a,4,6+16,4+3,h+1b,4mo,179q,2+9,2+11,2i9+7y,2+68,4,3+4,5+13,4+3,2+4k,3+29,8+cf,1t+7z,w+17,3+3m,1t+3z,16o1+5r,8+30,8+mc,29+1r,29+4v,75+73",
|
|
"EN": "1c+9,3d+1,6,187+9,513,4+5,7+9,sf+j,175h+9,qw+q,161f+1d,4xt+a,25i+9",
|
|
"ES": "17,2,6dp+1,f+1,av,16vr,mx+1,4o,2",
|
|
"ET": "z+2,3h+3,b+1,ym,3e+1,2o,p4+1,8,6u,7c,g6,1wc,1n9+4,30+1b,2n,6d,qhx+1,h0m,a+1,49+2,63+1,4+1,6bb+3,12jj",
|
|
"AN": "16o+5,2j+9,2+1,35,ed,1ff2+9,87+u",
|
|
"CS": "18,2+1,b,2u,12k,55v,l,17v0,2,3,53,2+1,b",
|
|
"B": "a,3,f+2,2v,690",
|
|
"S": "9,2,k",
|
|
"WS": "c,k,4f4,1vk+a,u,1j,335",
|
|
"ON": "x+1,4+4,h+5,r+5,r+3,z,5+3,2+1,2+1,5,2+2,3+4,o,w,ci+1,8+d,3+d,6+8,2+g,39+1,9,6+1,2,33,b8,3+1,3c+1,7+1,5r,b,7h+3,sa+5,2,3i+6,jg+3,ur+9,2v,ij+1,9g+9,7+a,8m,4+1,49+x,14u,2+2,c+2,e+2,e+2,e+1,i+n,e+e,2+p,u+2,e+2,36+1,2+3,2+1,b,2+2,6+5,2,2,2,h+1,5+4,6+3,3+f,16+2,5+3l,3+81,1y+p,2+40,q+a,m+13,2r+ch,2+9e,75+hf,3+v,2+2w,6e+5,f+6,75+2a,1a+p,2+2g,d+5x,r+b,6+3,4+o,g,6+1,6+2,2k+1,4,2j,5h+z,1m+1,1e+f,t+2,1f+e,d+3,4o+3,2s+1,w,535+1r,h3l+1i,93+2,2s,b+1,3l+x,2v,4g+3,21+3,kz+1,g5v+1,5a,j+9,n+v,2,3,2+8,2+1,3+2,2,3,46+1,4+4,h+5,r+5,r+a,3h+2,4+6,b+4,78,1r+24,4+c,4,1hb,ey+6,103+j,16j+c,1ux+7,5+g,fsh,jdq+1t,4,57+2e,p1,1m,1m,1m,1m,4kt+1,7j+17,5+2r,d+e,3+e,2+e,2+10,m+4,w,1n+5,1q,4z+5,4b+rb,9+c,4+c,4+37,d+2g,8+b,l+b,5+1j,9+9,7+13,9+t,3+1,27+3c,2+29,2+3q,d+d,3+4,4+2,6+6,a+o,8+6,a+2,e+6,16+42,2+1i",
|
|
"BN": "0+8,6+d,2s+5,2+p,e,4m9,1kt+2,2b+5,5+5,17q9+v,7k,6p+8,6+1,119d+3,440+7,96s+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+75,6p+2rz,1ben+1,1ekf+1,1ekf+1",
|
|
"NSM": "lc+33,7o+6,7c+18,2,2+1,2+1,2,21+a,1d+k,h,2u+6,3+5,3+1,2+3,10,v+q,2k+a,1n+8,a,p+3,2+8,2+2,2+4,18+2,3c+e,2+v,1k,2,5+7,5,4+6,b+1,u,1n,5+3,9,l+1,r,3+1,1m,5+1,5+1,3+2,4,v+1,4,c+1,1m,5+4,2+1,5,l+1,n+5,2,1n,3,2+3,9,8+1,c+1,v,1q,d,1f,4,1m+2,6+2,2+3,8+1,c+1,u,1n,g+1,l+1,t+1,1m+1,5+3,9,l+1,u,21,8+2,2,2j,3+6,d+7,2r,3+8,c+5,23+1,s,2,2,1k+d,2+4,2+1,6+a,2+z,a,2v+3,2+5,2+1,3+1,q+1,5+2,h+3,e,3+1,7,g,jk+2,qb+2,u+2,u+1,v+1,1t+1,2+6,9,3+a,a,1a+2,3c+1,z,3b+2,5+1,a,7+2,64+1,3,1n,2+6,2,2,3+7,7+9,3,1d+g,1s+3,1d,2+4,2,6,15+8,d+1,x+3,3+1,2+2,1l,2+1,4,2+2,1n+7,3+1,49+2,2+c,2+6,5,7,4+1,5j+1l,2+4,k1+w,2db+2,3y,2p+v,ff+3,30+1,n9x+3,2+9,x+1,29+1,7l,4,5,q+1,6,48+1,r+h,e,13+7,q+a,1b+2,1d,3+3,3+1,14,1w+5,3+1,3+1,d,9,1c,1g,2+2,3+1,6+1,2,17+1,9,6n,3,5,fn5,ki+f,h+f,r2,6b,46+4,1af+2,2+1,6+3,15+2,5,4m+1,fy+3,as+1,4a+a,4x,1j+e,1l+2,1e+3,3+1,1y+2,11+4,2+7,1r,d+1,1h+8,b+3,3,2o+2,3,2+1,7,4h,4+7,m+1,1m+1,4,12+6,4+4,5g+7,3+2,2,o,2d+5,2,5+1,2+1,6n+3,7+1,2+1,s+1,2e+7,3,2+1,2z,2,3+5,2,2u+2,3+3,2+4,78+8,2+1,75+1,2,5,41+3,3+1,5,x+5,3+1,15+5,3+3,9,a+5,3+2,1b+c,2+1,bb+6,2+5,2d+l,3+6,2+1,2+1,3f+5,4,2+1,2+6,2,21+1,4,2,9o+1,f0c+4,1o+6,t5,1s+3,2a,f5l+1,43t+2,i+7,3+6,v+3,45+2,1j0+1i,5+1d,9,f,n+4,2+e,11t+6,2+g,3+6,2+1,2+4,7a+6,c6+3,15t+6,32+6,gzhy+6n",
|
|
"AL": "16w,3,2,e+1b,z+2,2+2s,g+1,8+1,b+m,2+t,s+2i,c+e,4h+f,1d+1e,1bwe+dp,3+3z,x+c,2+1,35+3y,2rm+z,5+7,b+5,dt+l,c+u,17nl+27,1t+27,4x+6n,3+d",
|
|
"LRO": "6ct",
|
|
"RLO": "6cu",
|
|
"LRE": "6cq",
|
|
"RLE": "6cr",
|
|
"PDF": "6cs",
|
|
"LRI": "6ee",
|
|
"RLI": "6ef",
|
|
"FSI": "6eg",
|
|
"PDI": "6eh"
|
|
};
|
|
var TYPES = {};
|
|
var TYPES_TO_NAMES = {};
|
|
TYPES.L = 1;
|
|
TYPES_TO_NAMES[1] = "L";
|
|
Object.keys(DATA).forEach(function(type, i) {
|
|
TYPES[type] = 1 << i + 1;
|
|
TYPES_TO_NAMES[TYPES[type]] = type;
|
|
});
|
|
Object.freeze(TYPES);
|
|
var ISOLATE_INIT_TYPES = TYPES.LRI | TYPES.RLI | TYPES.FSI;
|
|
var STRONG_TYPES = TYPES.L | TYPES.R | TYPES.AL;
|
|
var NEUTRAL_ISOLATE_TYPES = TYPES.B | TYPES.S | TYPES.WS | TYPES.ON | TYPES.FSI | TYPES.LRI | TYPES.RLI | TYPES.PDI;
|
|
var BN_LIKE_TYPES = TYPES.BN | TYPES.RLE | TYPES.LRE | TYPES.RLO | TYPES.LRO | TYPES.PDF;
|
|
var TRAILING_TYPES = TYPES.S | TYPES.WS | TYPES.B | ISOLATE_INIT_TYPES | TYPES.PDI | BN_LIKE_TYPES;
|
|
var map = null;
|
|
function parseData() {
|
|
if (!map) {
|
|
map = /* @__PURE__ */ new Map();
|
|
var loop = function(type2) {
|
|
if (DATA.hasOwnProperty(type2)) {
|
|
var lastCode = 0;
|
|
DATA[type2].split(",").forEach(function(range) {
|
|
var ref = range.split("+");
|
|
var skip = ref[0];
|
|
var step = ref[1];
|
|
skip = parseInt(skip, 36);
|
|
step = step ? parseInt(step, 36) : 0;
|
|
map.set(lastCode += skip, TYPES[type2]);
|
|
for (var i = 0; i < step; i++) {
|
|
map.set(++lastCode, TYPES[type2]);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
for (var type in DATA) loop(type);
|
|
}
|
|
}
|
|
function getBidiCharType(char) {
|
|
parseData();
|
|
return map.get(char.codePointAt(0)) || TYPES.L;
|
|
}
|
|
function getBidiCharTypeName(char) {
|
|
return TYPES_TO_NAMES[getBidiCharType(char)];
|
|
}
|
|
var data$1 = {
|
|
"pairs": "14>1,1e>2,u>2,2wt>1,1>1,1ge>1,1wp>1,1j>1,f>1,hm>1,1>1,u>1,u6>1,1>1,+5,28>1,w>1,1>1,+3,b8>1,1>1,+3,1>3,-1>-1,3>1,1>1,+2,1s>1,1>1,x>1,th>1,1>1,+2,db>1,1>1,+3,3>1,1>1,+2,14qm>1,1>1,+1,4q>1,1e>2,u>2,2>1,+1",
|
|
"canonical": "6f1>-6dx,6dy>-6dx,6ec>-6ed,6ee>-6ed,6ww>2jj,-2ji>2jj,14r4>-1e7l,1e7m>-1e7l,1e7m>-1e5c,1e5d>-1e5b,1e5c>-14qx,14qy>-14qx,14vn>-1ecg,1ech>-1ecg,1edu>-1ecg,1eci>-1ecg,1eda>-1ecg,1eci>-1ecg,1eci>-168q,168r>-168q,168s>-14ye,14yf>-14ye"
|
|
};
|
|
function parseCharacterMap(encodedString, includeReverse) {
|
|
var radix = 36;
|
|
var lastCode = 0;
|
|
var map2 = /* @__PURE__ */ new Map();
|
|
var reverseMap = includeReverse && /* @__PURE__ */ new Map();
|
|
var prevPair;
|
|
encodedString.split(",").forEach(function visit(entry) {
|
|
if (entry.indexOf("+") !== -1) {
|
|
for (var i = +entry; i--; ) {
|
|
visit(prevPair);
|
|
}
|
|
} else {
|
|
prevPair = entry;
|
|
var ref = entry.split(">");
|
|
var a = ref[0];
|
|
var b = ref[1];
|
|
a = String.fromCodePoint(lastCode += parseInt(a, radix));
|
|
b = String.fromCodePoint(lastCode += parseInt(b, radix));
|
|
map2.set(a, b);
|
|
includeReverse && reverseMap.set(b, a);
|
|
}
|
|
});
|
|
return { map: map2, reverseMap };
|
|
}
|
|
var openToClose, closeToOpen, canonical;
|
|
function parse$1() {
|
|
if (!openToClose) {
|
|
var ref = parseCharacterMap(data$1.pairs, true);
|
|
var map2 = ref.map;
|
|
var reverseMap = ref.reverseMap;
|
|
openToClose = map2;
|
|
closeToOpen = reverseMap;
|
|
canonical = parseCharacterMap(data$1.canonical, false).map;
|
|
}
|
|
}
|
|
function openingToClosingBracket(char) {
|
|
parse$1();
|
|
return openToClose.get(char) || null;
|
|
}
|
|
function closingToOpeningBracket(char) {
|
|
parse$1();
|
|
return closeToOpen.get(char) || null;
|
|
}
|
|
function getCanonicalBracket(char) {
|
|
parse$1();
|
|
return canonical.get(char) || null;
|
|
}
|
|
var TYPE_L = TYPES.L;
|
|
var TYPE_R = TYPES.R;
|
|
var TYPE_EN = TYPES.EN;
|
|
var TYPE_ES = TYPES.ES;
|
|
var TYPE_ET = TYPES.ET;
|
|
var TYPE_AN = TYPES.AN;
|
|
var TYPE_CS = TYPES.CS;
|
|
var TYPE_B = TYPES.B;
|
|
var TYPE_S = TYPES.S;
|
|
var TYPE_ON = TYPES.ON;
|
|
var TYPE_BN = TYPES.BN;
|
|
var TYPE_NSM = TYPES.NSM;
|
|
var TYPE_AL = TYPES.AL;
|
|
var TYPE_LRO = TYPES.LRO;
|
|
var TYPE_RLO = TYPES.RLO;
|
|
var TYPE_LRE = TYPES.LRE;
|
|
var TYPE_RLE = TYPES.RLE;
|
|
var TYPE_PDF = TYPES.PDF;
|
|
var TYPE_LRI = TYPES.LRI;
|
|
var TYPE_RLI = TYPES.RLI;
|
|
var TYPE_FSI = TYPES.FSI;
|
|
var TYPE_PDI = TYPES.PDI;
|
|
function getEmbeddingLevels(string, baseDirection) {
|
|
var MAX_DEPTH = 125;
|
|
var charTypes = new Uint32Array(string.length);
|
|
for (var i = 0; i < string.length; i++) {
|
|
charTypes[i] = getBidiCharType(string[i]);
|
|
}
|
|
var charTypeCounts = /* @__PURE__ */ new Map();
|
|
function changeCharType(i2, type2) {
|
|
var oldType = charTypes[i2];
|
|
charTypes[i2] = type2;
|
|
charTypeCounts.set(oldType, charTypeCounts.get(oldType) - 1);
|
|
if (oldType & NEUTRAL_ISOLATE_TYPES) {
|
|
charTypeCounts.set(NEUTRAL_ISOLATE_TYPES, charTypeCounts.get(NEUTRAL_ISOLATE_TYPES) - 1);
|
|
}
|
|
charTypeCounts.set(type2, (charTypeCounts.get(type2) || 0) + 1);
|
|
if (type2 & NEUTRAL_ISOLATE_TYPES) {
|
|
charTypeCounts.set(NEUTRAL_ISOLATE_TYPES, (charTypeCounts.get(NEUTRAL_ISOLATE_TYPES) || 0) + 1);
|
|
}
|
|
}
|
|
var embedLevels = new Uint8Array(string.length);
|
|
var isolationPairs = /* @__PURE__ */ new Map();
|
|
var paragraphs = [];
|
|
var paragraph = null;
|
|
for (var i$1 = 0; i$1 < string.length; i$1++) {
|
|
if (!paragraph) {
|
|
paragraphs.push(paragraph = {
|
|
start: i$1,
|
|
end: string.length - 1,
|
|
// 3.3.1 P2-P3: Determine the paragraph level
|
|
level: baseDirection === "rtl" ? 1 : baseDirection === "ltr" ? 0 : determineAutoEmbedLevel(i$1, false)
|
|
});
|
|
}
|
|
if (charTypes[i$1] & TYPE_B) {
|
|
paragraph.end = i$1;
|
|
paragraph = null;
|
|
}
|
|
}
|
|
var FORMATTING_TYPES = TYPE_RLE | TYPE_LRE | TYPE_RLO | TYPE_LRO | ISOLATE_INIT_TYPES | TYPE_PDI | TYPE_PDF | TYPE_B;
|
|
var nextEven = function(n) {
|
|
return n + (n & 1 ? 1 : 2);
|
|
};
|
|
var nextOdd = function(n) {
|
|
return n + (n & 1 ? 2 : 1);
|
|
};
|
|
for (var paraIdx = 0; paraIdx < paragraphs.length; paraIdx++) {
|
|
paragraph = paragraphs[paraIdx];
|
|
var statusStack = [{
|
|
_level: paragraph.level,
|
|
_override: 0,
|
|
//0=neutral, 1=L, 2=R
|
|
_isolate: 0
|
|
//bool
|
|
}];
|
|
var stackTop = void 0;
|
|
var overflowIsolateCount = 0;
|
|
var overflowEmbeddingCount = 0;
|
|
var validIsolateCount = 0;
|
|
charTypeCounts.clear();
|
|
for (var i$2 = paragraph.start; i$2 <= paragraph.end; i$2++) {
|
|
var charType = charTypes[i$2];
|
|
stackTop = statusStack[statusStack.length - 1];
|
|
charTypeCounts.set(charType, (charTypeCounts.get(charType) || 0) + 1);
|
|
if (charType & NEUTRAL_ISOLATE_TYPES) {
|
|
charTypeCounts.set(NEUTRAL_ISOLATE_TYPES, (charTypeCounts.get(NEUTRAL_ISOLATE_TYPES) || 0) + 1);
|
|
}
|
|
if (charType & FORMATTING_TYPES) {
|
|
if (charType & (TYPE_RLE | TYPE_LRE)) {
|
|
embedLevels[i$2] = stackTop._level;
|
|
var level = (charType === TYPE_RLE ? nextOdd : nextEven)(stackTop._level);
|
|
if (level <= MAX_DEPTH && !overflowIsolateCount && !overflowEmbeddingCount) {
|
|
statusStack.push({
|
|
_level: level,
|
|
_override: 0,
|
|
_isolate: 0
|
|
});
|
|
} else if (!overflowIsolateCount) {
|
|
overflowEmbeddingCount++;
|
|
}
|
|
} else if (charType & (TYPE_RLO | TYPE_LRO)) {
|
|
embedLevels[i$2] = stackTop._level;
|
|
var level$1 = (charType === TYPE_RLO ? nextOdd : nextEven)(stackTop._level);
|
|
if (level$1 <= MAX_DEPTH && !overflowIsolateCount && !overflowEmbeddingCount) {
|
|
statusStack.push({
|
|
_level: level$1,
|
|
_override: charType & TYPE_RLO ? TYPE_R : TYPE_L,
|
|
_isolate: 0
|
|
});
|
|
} else if (!overflowIsolateCount) {
|
|
overflowEmbeddingCount++;
|
|
}
|
|
} else if (charType & ISOLATE_INIT_TYPES) {
|
|
if (charType & TYPE_FSI) {
|
|
charType = determineAutoEmbedLevel(i$2 + 1, true) === 1 ? TYPE_RLI : TYPE_LRI;
|
|
}
|
|
embedLevels[i$2] = stackTop._level;
|
|
if (stackTop._override) {
|
|
changeCharType(i$2, stackTop._override);
|
|
}
|
|
var level$2 = (charType === TYPE_RLI ? nextOdd : nextEven)(stackTop._level);
|
|
if (level$2 <= MAX_DEPTH && overflowIsolateCount === 0 && overflowEmbeddingCount === 0) {
|
|
validIsolateCount++;
|
|
statusStack.push({
|
|
_level: level$2,
|
|
_override: 0,
|
|
_isolate: 1,
|
|
_isolInitIndex: i$2
|
|
});
|
|
} else {
|
|
overflowIsolateCount++;
|
|
}
|
|
} else if (charType & TYPE_PDI) {
|
|
if (overflowIsolateCount > 0) {
|
|
overflowIsolateCount--;
|
|
} else if (validIsolateCount > 0) {
|
|
overflowEmbeddingCount = 0;
|
|
while (!statusStack[statusStack.length - 1]._isolate) {
|
|
statusStack.pop();
|
|
}
|
|
var isolInitIndex = statusStack[statusStack.length - 1]._isolInitIndex;
|
|
if (isolInitIndex != null) {
|
|
isolationPairs.set(isolInitIndex, i$2);
|
|
isolationPairs.set(i$2, isolInitIndex);
|
|
}
|
|
statusStack.pop();
|
|
validIsolateCount--;
|
|
}
|
|
stackTop = statusStack[statusStack.length - 1];
|
|
embedLevels[i$2] = stackTop._level;
|
|
if (stackTop._override) {
|
|
changeCharType(i$2, stackTop._override);
|
|
}
|
|
} else if (charType & TYPE_PDF) {
|
|
if (overflowIsolateCount === 0) {
|
|
if (overflowEmbeddingCount > 0) {
|
|
overflowEmbeddingCount--;
|
|
} else if (!stackTop._isolate && statusStack.length > 1) {
|
|
statusStack.pop();
|
|
stackTop = statusStack[statusStack.length - 1];
|
|
}
|
|
}
|
|
embedLevels[i$2] = stackTop._level;
|
|
} else if (charType & TYPE_B) {
|
|
embedLevels[i$2] = paragraph.level;
|
|
}
|
|
} else {
|
|
embedLevels[i$2] = stackTop._level;
|
|
if (stackTop._override && charType !== TYPE_BN) {
|
|
changeCharType(i$2, stackTop._override);
|
|
}
|
|
}
|
|
}
|
|
var levelRuns = [];
|
|
var currentRun = null;
|
|
for (var i$3 = paragraph.start; i$3 <= paragraph.end; i$3++) {
|
|
var charType$1 = charTypes[i$3];
|
|
if (!(charType$1 & BN_LIKE_TYPES)) {
|
|
var lvl = embedLevels[i$3];
|
|
var isIsolInit = charType$1 & ISOLATE_INIT_TYPES;
|
|
var isPDI = charType$1 === TYPE_PDI;
|
|
if (currentRun && lvl === currentRun._level) {
|
|
currentRun._end = i$3;
|
|
currentRun._endsWithIsolInit = isIsolInit;
|
|
} else {
|
|
levelRuns.push(currentRun = {
|
|
_start: i$3,
|
|
_end: i$3,
|
|
_level: lvl,
|
|
_startsWithPDI: isPDI,
|
|
_endsWithIsolInit: isIsolInit
|
|
});
|
|
}
|
|
}
|
|
}
|
|
var isolatingRunSeqs = [];
|
|
for (var runIdx = 0; runIdx < levelRuns.length; runIdx++) {
|
|
var run = levelRuns[runIdx];
|
|
if (!run._startsWithPDI || run._startsWithPDI && !isolationPairs.has(run._start)) {
|
|
var seqRuns = [currentRun = run];
|
|
for (var pdiIndex = void 0; currentRun && currentRun._endsWithIsolInit && (pdiIndex = isolationPairs.get(currentRun._end)) != null; ) {
|
|
for (var i$4 = runIdx + 1; i$4 < levelRuns.length; i$4++) {
|
|
if (levelRuns[i$4]._start === pdiIndex) {
|
|
seqRuns.push(currentRun = levelRuns[i$4]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
var seqIndices = [];
|
|
for (var i$5 = 0; i$5 < seqRuns.length; i$5++) {
|
|
var run$1 = seqRuns[i$5];
|
|
for (var j = run$1._start; j <= run$1._end; j++) {
|
|
seqIndices.push(j);
|
|
}
|
|
}
|
|
var firstLevel = embedLevels[seqIndices[0]];
|
|
var prevLevel = paragraph.level;
|
|
for (var i$6 = seqIndices[0] - 1; i$6 >= 0; i$6--) {
|
|
if (!(charTypes[i$6] & BN_LIKE_TYPES)) {
|
|
prevLevel = embedLevels[i$6];
|
|
break;
|
|
}
|
|
}
|
|
var lastIndex = seqIndices[seqIndices.length - 1];
|
|
var lastLevel = embedLevels[lastIndex];
|
|
var nextLevel = paragraph.level;
|
|
if (!(charTypes[lastIndex] & ISOLATE_INIT_TYPES)) {
|
|
for (var i$7 = lastIndex + 1; i$7 <= paragraph.end; i$7++) {
|
|
if (!(charTypes[i$7] & BN_LIKE_TYPES)) {
|
|
nextLevel = embedLevels[i$7];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
isolatingRunSeqs.push({
|
|
_seqIndices: seqIndices,
|
|
_sosType: Math.max(prevLevel, firstLevel) % 2 ? TYPE_R : TYPE_L,
|
|
_eosType: Math.max(nextLevel, lastLevel) % 2 ? TYPE_R : TYPE_L
|
|
});
|
|
}
|
|
}
|
|
for (var seqIdx = 0; seqIdx < isolatingRunSeqs.length; seqIdx++) {
|
|
var ref = isolatingRunSeqs[seqIdx];
|
|
var seqIndices$1 = ref._seqIndices;
|
|
var sosType = ref._sosType;
|
|
var eosType = ref._eosType;
|
|
if (charTypeCounts.get(TYPE_NSM)) {
|
|
for (var si = 0; si < seqIndices$1.length; si++) {
|
|
var i$8 = seqIndices$1[si];
|
|
if (charTypes[i$8] & TYPE_NSM) {
|
|
var prevType = sosType;
|
|
for (var sj = si - 1; sj >= 0; sj--) {
|
|
if (!(charTypes[seqIndices$1[sj]] & BN_LIKE_TYPES)) {
|
|
prevType = charTypes[seqIndices$1[sj]];
|
|
break;
|
|
}
|
|
}
|
|
changeCharType(i$8, prevType & (ISOLATE_INIT_TYPES | TYPE_PDI) ? TYPE_ON : prevType);
|
|
}
|
|
}
|
|
}
|
|
if (charTypeCounts.get(TYPE_EN)) {
|
|
for (var si$1 = 0; si$1 < seqIndices$1.length; si$1++) {
|
|
var i$9 = seqIndices$1[si$1];
|
|
if (charTypes[i$9] & TYPE_EN) {
|
|
for (var sj$1 = si$1 - 1; sj$1 >= -1; sj$1--) {
|
|
var prevCharType = sj$1 === -1 ? sosType : charTypes[seqIndices$1[sj$1]];
|
|
if (prevCharType & STRONG_TYPES) {
|
|
if (prevCharType === TYPE_AL) {
|
|
changeCharType(i$9, TYPE_AN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (charTypeCounts.get(TYPE_AL)) {
|
|
for (var si$2 = 0; si$2 < seqIndices$1.length; si$2++) {
|
|
var i$10 = seqIndices$1[si$2];
|
|
if (charTypes[i$10] & TYPE_AL) {
|
|
changeCharType(i$10, TYPE_R);
|
|
}
|
|
}
|
|
}
|
|
if (charTypeCounts.get(TYPE_ES) || charTypeCounts.get(TYPE_CS)) {
|
|
for (var si$3 = 1; si$3 < seqIndices$1.length - 1; si$3++) {
|
|
var i$11 = seqIndices$1[si$3];
|
|
if (charTypes[i$11] & (TYPE_ES | TYPE_CS)) {
|
|
var prevType$1 = 0, nextType = 0;
|
|
for (var sj$2 = si$3 - 1; sj$2 >= 0; sj$2--) {
|
|
prevType$1 = charTypes[seqIndices$1[sj$2]];
|
|
if (!(prevType$1 & BN_LIKE_TYPES)) {
|
|
break;
|
|
}
|
|
}
|
|
for (var sj$3 = si$3 + 1; sj$3 < seqIndices$1.length; sj$3++) {
|
|
nextType = charTypes[seqIndices$1[sj$3]];
|
|
if (!(nextType & BN_LIKE_TYPES)) {
|
|
break;
|
|
}
|
|
}
|
|
if (prevType$1 === nextType && (charTypes[i$11] === TYPE_ES ? prevType$1 === TYPE_EN : prevType$1 & (TYPE_EN | TYPE_AN))) {
|
|
changeCharType(i$11, prevType$1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (charTypeCounts.get(TYPE_EN)) {
|
|
for (var si$4 = 0; si$4 < seqIndices$1.length; si$4++) {
|
|
var i$12 = seqIndices$1[si$4];
|
|
if (charTypes[i$12] & TYPE_EN) {
|
|
for (var sj$4 = si$4 - 1; sj$4 >= 0 && charTypes[seqIndices$1[sj$4]] & (TYPE_ET | BN_LIKE_TYPES); sj$4--) {
|
|
changeCharType(seqIndices$1[sj$4], TYPE_EN);
|
|
}
|
|
for (var sj$5 = si$4 + 1; sj$5 < seqIndices$1.length && charTypes[seqIndices$1[sj$5]] & (TYPE_ET | BN_LIKE_TYPES); sj$5++) {
|
|
changeCharType(seqIndices$1[sj$5], TYPE_EN);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (charTypeCounts.get(TYPE_ET) || charTypeCounts.get(TYPE_ES) || charTypeCounts.get(TYPE_CS)) {
|
|
for (var si$5 = 0; si$5 < seqIndices$1.length; si$5++) {
|
|
var i$13 = seqIndices$1[si$5];
|
|
if (charTypes[i$13] & (TYPE_ET | TYPE_ES | TYPE_CS)) {
|
|
changeCharType(i$13, TYPE_ON);
|
|
for (var sj$6 = si$5 - 1; sj$6 >= 0 && charTypes[seqIndices$1[sj$6]] & BN_LIKE_TYPES; sj$6--) {
|
|
changeCharType(seqIndices$1[sj$6], TYPE_ON);
|
|
}
|
|
for (var sj$7 = si$5 + 1; sj$7 < seqIndices$1.length && charTypes[seqIndices$1[sj$7]] & BN_LIKE_TYPES; sj$7++) {
|
|
changeCharType(seqIndices$1[sj$7], TYPE_ON);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (charTypeCounts.get(TYPE_EN)) {
|
|
for (var si$6 = 0, prevStrongType = sosType; si$6 < seqIndices$1.length; si$6++) {
|
|
var i$14 = seqIndices$1[si$6];
|
|
var type = charTypes[i$14];
|
|
if (type & TYPE_EN) {
|
|
if (prevStrongType === TYPE_L) {
|
|
changeCharType(i$14, TYPE_L);
|
|
}
|
|
} else if (type & STRONG_TYPES) {
|
|
prevStrongType = type;
|
|
}
|
|
}
|
|
}
|
|
if (charTypeCounts.get(NEUTRAL_ISOLATE_TYPES)) {
|
|
var R_TYPES_FOR_N_STEPS = TYPE_R | TYPE_EN | TYPE_AN;
|
|
var STRONG_TYPES_FOR_N_STEPS = R_TYPES_FOR_N_STEPS | TYPE_L;
|
|
var bracketPairs = [];
|
|
{
|
|
var openerStack = [];
|
|
for (var si$7 = 0; si$7 < seqIndices$1.length; si$7++) {
|
|
if (charTypes[seqIndices$1[si$7]] & NEUTRAL_ISOLATE_TYPES) {
|
|
var char = string[seqIndices$1[si$7]];
|
|
var oppositeBracket = void 0;
|
|
if (openingToClosingBracket(char) !== null) {
|
|
if (openerStack.length < 63) {
|
|
openerStack.push({ char, seqIndex: si$7 });
|
|
} else {
|
|
break;
|
|
}
|
|
} else if ((oppositeBracket = closingToOpeningBracket(char)) !== null) {
|
|
for (var stackIdx = openerStack.length - 1; stackIdx >= 0; stackIdx--) {
|
|
var stackChar = openerStack[stackIdx].char;
|
|
if (stackChar === oppositeBracket || stackChar === closingToOpeningBracket(getCanonicalBracket(char)) || openingToClosingBracket(getCanonicalBracket(stackChar)) === char) {
|
|
bracketPairs.push([openerStack[stackIdx].seqIndex, si$7]);
|
|
openerStack.length = stackIdx;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
bracketPairs.sort(function(a, b) {
|
|
return a[0] - b[0];
|
|
});
|
|
}
|
|
for (var pairIdx = 0; pairIdx < bracketPairs.length; pairIdx++) {
|
|
var ref$1 = bracketPairs[pairIdx];
|
|
var openSeqIdx = ref$1[0];
|
|
var closeSeqIdx = ref$1[1];
|
|
var foundStrongType = false;
|
|
var useStrongType = 0;
|
|
for (var si$8 = openSeqIdx + 1; si$8 < closeSeqIdx; si$8++) {
|
|
var i$15 = seqIndices$1[si$8];
|
|
if (charTypes[i$15] & STRONG_TYPES_FOR_N_STEPS) {
|
|
foundStrongType = true;
|
|
var lr = charTypes[i$15] & R_TYPES_FOR_N_STEPS ? TYPE_R : TYPE_L;
|
|
if (lr === getEmbedDirection(i$15)) {
|
|
useStrongType = lr;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (foundStrongType && !useStrongType) {
|
|
useStrongType = sosType;
|
|
for (var si$9 = openSeqIdx - 1; si$9 >= 0; si$9--) {
|
|
var i$16 = seqIndices$1[si$9];
|
|
if (charTypes[i$16] & STRONG_TYPES_FOR_N_STEPS) {
|
|
var lr$1 = charTypes[i$16] & R_TYPES_FOR_N_STEPS ? TYPE_R : TYPE_L;
|
|
if (lr$1 !== getEmbedDirection(i$16)) {
|
|
useStrongType = lr$1;
|
|
} else {
|
|
useStrongType = getEmbedDirection(i$16);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (useStrongType) {
|
|
charTypes[seqIndices$1[openSeqIdx]] = charTypes[seqIndices$1[closeSeqIdx]] = useStrongType;
|
|
if (useStrongType !== getEmbedDirection(seqIndices$1[openSeqIdx])) {
|
|
for (var si$10 = openSeqIdx + 1; si$10 < seqIndices$1.length; si$10++) {
|
|
if (!(charTypes[seqIndices$1[si$10]] & BN_LIKE_TYPES)) {
|
|
if (getBidiCharType(string[seqIndices$1[si$10]]) & TYPE_NSM) {
|
|
charTypes[seqIndices$1[si$10]] = useStrongType;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (useStrongType !== getEmbedDirection(seqIndices$1[closeSeqIdx])) {
|
|
for (var si$11 = closeSeqIdx + 1; si$11 < seqIndices$1.length; si$11++) {
|
|
if (!(charTypes[seqIndices$1[si$11]] & BN_LIKE_TYPES)) {
|
|
if (getBidiCharType(string[seqIndices$1[si$11]]) & TYPE_NSM) {
|
|
charTypes[seqIndices$1[si$11]] = useStrongType;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (var si$12 = 0; si$12 < seqIndices$1.length; si$12++) {
|
|
if (charTypes[seqIndices$1[si$12]] & NEUTRAL_ISOLATE_TYPES) {
|
|
var niRunStart = si$12, niRunEnd = si$12;
|
|
var prevType$2 = sosType;
|
|
for (var si2 = si$12 - 1; si2 >= 0; si2--) {
|
|
if (charTypes[seqIndices$1[si2]] & BN_LIKE_TYPES) {
|
|
niRunStart = si2;
|
|
} else {
|
|
prevType$2 = charTypes[seqIndices$1[si2]] & R_TYPES_FOR_N_STEPS ? TYPE_R : TYPE_L;
|
|
break;
|
|
}
|
|
}
|
|
var nextType$1 = eosType;
|
|
for (var si2$1 = si$12 + 1; si2$1 < seqIndices$1.length; si2$1++) {
|
|
if (charTypes[seqIndices$1[si2$1]] & (NEUTRAL_ISOLATE_TYPES | BN_LIKE_TYPES)) {
|
|
niRunEnd = si2$1;
|
|
} else {
|
|
nextType$1 = charTypes[seqIndices$1[si2$1]] & R_TYPES_FOR_N_STEPS ? TYPE_R : TYPE_L;
|
|
break;
|
|
}
|
|
}
|
|
for (var sj$8 = niRunStart; sj$8 <= niRunEnd; sj$8++) {
|
|
charTypes[seqIndices$1[sj$8]] = prevType$2 === nextType$1 ? prevType$2 : getEmbedDirection(seqIndices$1[sj$8]);
|
|
}
|
|
si$12 = niRunEnd;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (var i$17 = paragraph.start; i$17 <= paragraph.end; i$17++) {
|
|
var level$3 = embedLevels[i$17];
|
|
var type$1 = charTypes[i$17];
|
|
if (level$3 & 1) {
|
|
if (type$1 & (TYPE_L | TYPE_EN | TYPE_AN)) {
|
|
embedLevels[i$17]++;
|
|
}
|
|
} else {
|
|
if (type$1 & TYPE_R) {
|
|
embedLevels[i$17]++;
|
|
} else if (type$1 & (TYPE_AN | TYPE_EN)) {
|
|
embedLevels[i$17] += 2;
|
|
}
|
|
}
|
|
if (type$1 & BN_LIKE_TYPES) {
|
|
embedLevels[i$17] = i$17 === 0 ? paragraph.level : embedLevels[i$17 - 1];
|
|
}
|
|
if (i$17 === paragraph.end || getBidiCharType(string[i$17]) & (TYPE_S | TYPE_B)) {
|
|
for (var j$1 = i$17; j$1 >= 0 && getBidiCharType(string[j$1]) & TRAILING_TYPES; j$1--) {
|
|
embedLevels[j$1] = paragraph.level;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
levels: embedLevels,
|
|
paragraphs
|
|
};
|
|
function determineAutoEmbedLevel(start, isFSI) {
|
|
for (var i2 = start; i2 < string.length; i2++) {
|
|
var charType2 = charTypes[i2];
|
|
if (charType2 & (TYPE_R | TYPE_AL)) {
|
|
return 1;
|
|
}
|
|
if (charType2 & (TYPE_B | TYPE_L) || isFSI && charType2 === TYPE_PDI) {
|
|
return 0;
|
|
}
|
|
if (charType2 & ISOLATE_INIT_TYPES) {
|
|
var pdi = indexOfMatchingPDI(i2);
|
|
i2 = pdi === -1 ? string.length : pdi;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
function indexOfMatchingPDI(isolateStart) {
|
|
var isolationLevel = 1;
|
|
for (var i2 = isolateStart + 1; i2 < string.length; i2++) {
|
|
var charType2 = charTypes[i2];
|
|
if (charType2 & TYPE_B) {
|
|
break;
|
|
}
|
|
if (charType2 & TYPE_PDI) {
|
|
if (--isolationLevel === 0) {
|
|
return i2;
|
|
}
|
|
} else if (charType2 & ISOLATE_INIT_TYPES) {
|
|
isolationLevel++;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function getEmbedDirection(i2) {
|
|
return embedLevels[i2] & 1 ? TYPE_R : TYPE_L;
|
|
}
|
|
}
|
|
var data = "14>1,j>2,t>2,u>2,1a>g,2v3>1,1>1,1ge>1,1wd>1,b>1,1j>1,f>1,ai>3,-2>3,+1,8>1k0,-1jq>1y7,-1y6>1hf,-1he>1h6,-1h5>1ha,-1h8>1qi,-1pu>1,6>3u,-3s>7,6>1,1>1,f>1,1>1,+2,3>1,1>1,+13,4>1,1>1,6>1eo,-1ee>1,3>1mg,-1me>1mk,-1mj>1mi,-1mg>1mi,-1md>1,1>1,+2,1>10k,-103>1,1>1,4>1,5>1,1>1,+10,3>1,1>8,-7>8,+1,-6>7,+1,a>1,1>1,u>1,u6>1,1>1,+5,26>1,1>1,2>1,2>2,8>1,7>1,4>1,1>1,+5,b8>1,1>1,+3,1>3,-2>1,2>1,1>1,+2,c>1,3>1,1>1,+2,h>1,3>1,a>1,1>1,2>1,3>1,1>1,d>1,f>1,3>1,1a>1,1>1,6>1,7>1,13>1,k>1,1>1,+19,4>1,1>1,+2,2>1,1>1,+18,m>1,a>1,1>1,lk>1,1>1,4>1,2>1,f>1,3>1,1>1,+3,db>1,1>1,+3,3>1,1>1,+2,14qm>1,1>1,+1,6>1,4j>1,j>2,t>2,u>2,2>1,+1";
|
|
var mirrorMap;
|
|
function parse() {
|
|
if (!mirrorMap) {
|
|
var ref = parseCharacterMap(data, true);
|
|
var map2 = ref.map;
|
|
var reverseMap = ref.reverseMap;
|
|
reverseMap.forEach(function(value, key) {
|
|
map2.set(key, value);
|
|
});
|
|
mirrorMap = map2;
|
|
}
|
|
}
|
|
function getMirroredCharacter(char) {
|
|
parse();
|
|
return mirrorMap.get(char) || null;
|
|
}
|
|
function getMirroredCharactersMap(string, embeddingLevels, start, end) {
|
|
var strLen = string.length;
|
|
start = Math.max(0, start == null ? 0 : +start);
|
|
end = Math.min(strLen - 1, end == null ? strLen - 1 : +end);
|
|
var map2 = /* @__PURE__ */ new Map();
|
|
for (var i = start; i <= end; i++) {
|
|
if (embeddingLevels[i] & 1) {
|
|
var mirror = getMirroredCharacter(string[i]);
|
|
if (mirror !== null) {
|
|
map2.set(i, mirror);
|
|
}
|
|
}
|
|
}
|
|
return map2;
|
|
}
|
|
function getReorderSegments(string, embeddingLevelsResult, start, end) {
|
|
var strLen = string.length;
|
|
start = Math.max(0, start == null ? 0 : +start);
|
|
end = Math.min(strLen - 1, end == null ? strLen - 1 : +end);
|
|
var segments = [];
|
|
embeddingLevelsResult.paragraphs.forEach(function(paragraph) {
|
|
var lineStart = Math.max(start, paragraph.start);
|
|
var lineEnd = Math.min(end, paragraph.end);
|
|
if (lineStart < lineEnd) {
|
|
var lineLevels = embeddingLevelsResult.levels.slice(lineStart, lineEnd + 1);
|
|
for (var i = lineEnd; i >= lineStart && getBidiCharType(string[i]) & TRAILING_TYPES; i--) {
|
|
lineLevels[i] = paragraph.level;
|
|
}
|
|
var maxLevel = paragraph.level;
|
|
var minOddLevel = Infinity;
|
|
for (var i$1 = 0; i$1 < lineLevels.length; i$1++) {
|
|
var level = lineLevels[i$1];
|
|
if (level > maxLevel) {
|
|
maxLevel = level;
|
|
}
|
|
if (level < minOddLevel) {
|
|
minOddLevel = level | 1;
|
|
}
|
|
}
|
|
for (var lvl = maxLevel; lvl >= minOddLevel; lvl--) {
|
|
for (var i$2 = 0; i$2 < lineLevels.length; i$2++) {
|
|
if (lineLevels[i$2] >= lvl) {
|
|
var segStart = i$2;
|
|
while (i$2 + 1 < lineLevels.length && lineLevels[i$2 + 1] >= lvl) {
|
|
i$2++;
|
|
}
|
|
if (i$2 > segStart) {
|
|
segments.push([segStart + start, i$2 + start]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return segments;
|
|
}
|
|
function getReorderedString(string, embedLevelsResult, start, end) {
|
|
var indices = getReorderedIndices(string, embedLevelsResult, start, end);
|
|
var chars = [].concat(string);
|
|
indices.forEach(function(charIndex, i) {
|
|
chars[i] = (embedLevelsResult.levels[charIndex] & 1 ? getMirroredCharacter(string[charIndex]) : null) || string[charIndex];
|
|
});
|
|
return chars.join("");
|
|
}
|
|
function getReorderedIndices(string, embedLevelsResult, start, end) {
|
|
var segments = getReorderSegments(string, embedLevelsResult, start, end);
|
|
var indices = [];
|
|
for (var i = 0; i < string.length; i++) {
|
|
indices[i] = i;
|
|
}
|
|
segments.forEach(function(ref) {
|
|
var start2 = ref[0];
|
|
var end2 = ref[1];
|
|
var slice = indices.slice(start2, end2 + 1);
|
|
for (var i2 = slice.length; i2--; ) {
|
|
indices[end2 - i2] = slice[i2];
|
|
}
|
|
});
|
|
return indices;
|
|
}
|
|
exports.closingToOpeningBracket = closingToOpeningBracket;
|
|
exports.getBidiCharType = getBidiCharType;
|
|
exports.getBidiCharTypeName = getBidiCharTypeName;
|
|
exports.getCanonicalBracket = getCanonicalBracket;
|
|
exports.getEmbeddingLevels = getEmbeddingLevels;
|
|
exports.getMirroredCharacter = getMirroredCharacter;
|
|
exports.getMirroredCharactersMap = getMirroredCharactersMap;
|
|
exports.getReorderSegments = getReorderSegments;
|
|
exports.getReorderedIndices = getReorderedIndices;
|
|
exports.getReorderedString = getReorderedString;
|
|
exports.openingToClosingBracket = openingToClosingBracket;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
return exports;
|
|
}({});
|
|
return bidi;
|
|
}
|
|
var bidi_default = bidiFactory;
|
|
|
|
export {
|
|
defineWorkerModule,
|
|
terminateWorker,
|
|
SDFGenerator,
|
|
bidi_default
|
|
};
|
|
//# sourceMappingURL=chunk-ZMJJZNZH.js.map
|