pdfmake
Version:
Client/server side PDF printing in pure JavaScript
3,834 lines • 132 kB
JavaScript
"use strict";
var SVGtoPDF = function (doc, svg, x, y, options) {
"use strict";
const NamedColors = {
aliceblue: [240, 248, 255],
antiquewhite: [250, 235, 215],
aqua: [0, 255, 255],
aquamarine: [127, 255, 212],
azure: [240, 255, 255],
beige: [245, 245, 220],
bisque: [255, 228, 196],
black: [0, 0, 0],
blanchedalmond: [255, 235, 205],
blue: [0, 0, 255],
blueviolet: [138, 43, 226],
brown: [165, 42, 42],
burlywood: [222, 184, 135],
cadetblue: [95, 158, 160],
chartreuse: [127, 255, 0],
chocolate: [210, 105, 30],
coral: [255, 127, 80],
cornflowerblue: [100, 149, 237],
cornsilk: [255, 248, 220],
crimson: [220, 20, 60],
cyan: [0, 255, 255],
darkblue: [0, 0, 139],
darkcyan: [0, 139, 139],
darkgoldenrod: [184, 134, 11],
darkgray: [169, 169, 169],
darkgrey: [169, 169, 169],
darkgreen: [0, 100, 0],
darkkhaki: [189, 183, 107],
darkmagenta: [139, 0, 139],
darkolivegreen: [85, 107, 47],
darkorange: [255, 140, 0],
darkorchid: [153, 50, 204],
darkred: [139, 0, 0],
darksalmon: [233, 150, 122],
darkseagreen: [143, 188, 143],
darkslateblue: [72, 61, 139],
darkslategray: [47, 79, 79],
darkslategrey: [47, 79, 79],
darkturquoise: [0, 206, 209],
darkviolet: [148, 0, 211],
deeppink: [255, 20, 147],
deepskyblue: [0, 191, 255],
dimgray: [105, 105, 105],
dimgrey: [105, 105, 105],
dodgerblue: [30, 144, 255],
firebrick: [178, 34, 34],
floralwhite: [255, 250, 240],
forestgreen: [34, 139, 34],
fuchsia: [255, 0, 255],
gainsboro: [220, 220, 220],
ghostwhite: [248, 248, 255],
gold: [255, 215, 0],
goldenrod: [218, 165, 32],
gray: [128, 128, 128],
grey: [128, 128, 128],
green: [0, 128, 0],
greenyellow: [173, 255, 47],
honeydew: [240, 255, 240],
hotpink: [255, 105, 180],
indianred: [205, 92, 92],
indigo: [75, 0, 130],
ivory: [255, 255, 240],
khaki: [240, 230, 140],
lavender: [230, 230, 250],
lavenderblush: [255, 240, 245],
lawngreen: [124, 252, 0],
lemonchiffon: [255, 250, 205],
lightblue: [173, 216, 230],
lightcoral: [240, 128, 128],
lightcyan: [224, 255, 255],
lightgoldenrodyellow: [250, 250, 210],
lightgray: [211, 211, 211],
lightgrey: [211, 211, 211],
lightgreen: [144, 238, 144],
lightpink: [255, 182, 193],
lightsalmon: [255, 160, 122],
lightseagreen: [32, 178, 170],
lightskyblue: [135, 206, 250],
lightslategray: [119, 136, 153],
lightslategrey: [119, 136, 153],
lightsteelblue: [176, 196, 222],
lightyellow: [255, 255, 224],
lime: [0, 255, 0],
limegreen: [50, 205, 50],
linen: [250, 240, 230],
magenta: [255, 0, 255],
maroon: [128, 0, 0],
mediumaquamarine: [102, 205, 170],
mediumblue: [0, 0, 205],
mediumorchid: [186, 85, 211],
mediumpurple: [147, 112, 219],
mediumseagreen: [60, 179, 113],
mediumslateblue: [123, 104, 238],
mediumspringgreen: [0, 250, 154],
mediumturquoise: [72, 209, 204],
mediumvioletred: [199, 21, 133],
midnightblue: [25, 25, 112],
mintcream: [245, 255, 250],
mistyrose: [255, 228, 225],
moccasin: [255, 228, 181],
navajowhite: [255, 222, 173],
navy: [0, 0, 128],
oldlace: [253, 245, 230],
olive: [128, 128, 0],
olivedrab: [107, 142, 35],
orange: [255, 165, 0],
orangered: [255, 69, 0],
orchid: [218, 112, 214],
palegoldenrod: [238, 232, 170],
palegreen: [152, 251, 152],
paleturquoise: [175, 238, 238],
palevioletred: [219, 112, 147],
papayawhip: [255, 239, 213],
peachpuff: [255, 218, 185],
peru: [205, 133, 63],
pink: [255, 192, 203],
plum: [221, 160, 221],
powderblue: [176, 224, 230],
purple: [128, 0, 128],
rebeccapurple: [102, 51, 153],
red: [255, 0, 0],
rosybrown: [188, 143, 143],
royalblue: [65, 105, 225],
saddlebrown: [139, 69, 19],
salmon: [250, 128, 114],
sandybrown: [244, 164, 96],
seagreen: [46, 139, 87],
seashell: [255, 245, 238],
sienna: [160, 82, 45],
silver: [192, 192, 192],
skyblue: [135, 206, 235],
slateblue: [106, 90, 205],
slategray: [112, 128, 144],
slategrey: [112, 128, 144],
snow: [255, 250, 250],
springgreen: [0, 255, 127],
steelblue: [70, 130, 180],
tan: [210, 180, 140],
teal: [0, 128, 128],
thistle: [216, 191, 216],
tomato: [255, 99, 71],
turquoise: [64, 224, 208],
violet: [238, 130, 238],
wheat: [245, 222, 179],
white: [255, 255, 255],
whitesmoke: [245, 245, 245],
yellow: [255, 255, 0]
};
const DefaultColors = {
black: [NamedColors.black, 1],
white: [NamedColors.white, 1],
transparent: [NamedColors.black, 0]
};
const Entities = {
quot: 34,
amp: 38,
lt: 60,
gt: 62,
apos: 39,
OElig: 338,
oelig: 339,
Scaron: 352,
scaron: 353,
Yuml: 376,
circ: 710,
tilde: 732,
ensp: 8194,
emsp: 8195,
thinsp: 8201,
zwnj: 8204,
zwj: 8205,
lrm: 8206,
rlm: 8207,
ndash: 8211,
mdash: 8212,
lsquo: 8216,
rsquo: 8217,
sbquo: 8218,
ldquo: 8220,
rdquo: 8221,
bdquo: 8222,
dagger: 8224,
Dagger: 8225,
permil: 8240,
lsaquo: 8249,
rsaquo: 8250,
euro: 8364,
nbsp: 160,
iexcl: 161,
cent: 162,
pound: 163,
curren: 164,
yen: 165,
brvbar: 166,
sect: 167,
uml: 168,
copy: 169,
ordf: 170,
laquo: 171,
not: 172,
shy: 173,
reg: 174,
macr: 175,
deg: 176,
plusmn: 177,
sup2: 178,
sup3: 179,
acute: 180,
micro: 181,
para: 182,
middot: 183,
cedil: 184,
sup1: 185,
ordm: 186,
raquo: 187,
frac14: 188,
frac12: 189,
frac34: 190,
iquest: 191,
Agrave: 192,
Aacute: 193,
Acirc: 194,
Atilde: 195,
Auml: 196,
Aring: 197,
AElig: 198,
Ccedil: 199,
Egrave: 200,
Eacute: 201,
Ecirc: 202,
Euml: 203,
Igrave: 204,
Iacute: 205,
Icirc: 206,
Iuml: 207,
ETH: 208,
Ntilde: 209,
Ograve: 210,
Oacute: 211,
Ocirc: 212,
Otilde: 213,
Ouml: 214,
times: 215,
Oslash: 216,
Ugrave: 217,
Uacute: 218,
Ucirc: 219,
Uuml: 220,
Yacute: 221,
THORN: 222,
szlig: 223,
agrave: 224,
aacute: 225,
acirc: 226,
atilde: 227,
auml: 228,
aring: 229,
aelig: 230,
ccedil: 231,
egrave: 232,
eacute: 233,
ecirc: 234,
euml: 235,
igrave: 236,
iacute: 237,
icirc: 238,
iuml: 239,
eth: 240,
ntilde: 241,
ograve: 242,
oacute: 243,
ocirc: 244,
otilde: 245,
ouml: 246,
divide: 247,
oslash: 248,
ugrave: 249,
uacute: 250,
ucirc: 251,
uuml: 252,
yacute: 253,
thorn: 254,
yuml: 255,
fnof: 402,
Alpha: 913,
Beta: 914,
Gamma: 915,
Delta: 916,
Epsilon: 917,
Zeta: 918,
Eta: 919,
Theta: 920,
Iota: 921,
Kappa: 922,
Lambda: 923,
Mu: 924,
Nu: 925,
Xi: 926,
Omicron: 927,
Pi: 928,
Rho: 929,
Sigma: 931,
Tau: 932,
Upsilon: 933,
Phi: 934,
Chi: 935,
Psi: 936,
Omega: 937,
alpha: 945,
beta: 946,
gamma: 947,
delta: 948,
epsilon: 949,
zeta: 950,
eta: 951,
theta: 952,
iota: 953,
kappa: 954,
lambda: 955,
mu: 956,
nu: 957,
xi: 958,
omicron: 959,
pi: 960,
rho: 961,
sigmaf: 962,
sigma: 963,
tau: 964,
upsilon: 965,
phi: 966,
chi: 967,
psi: 968,
omega: 969,
thetasym: 977,
upsih: 978,
piv: 982,
bull: 8226,
hellip: 8230,
prime: 8242,
Prime: 8243,
oline: 8254,
frasl: 8260,
weierp: 8472,
image: 8465,
real: 8476,
trade: 8482,
alefsym: 8501,
larr: 8592,
uarr: 8593,
rarr: 8594,
darr: 8595,
harr: 8596,
crarr: 8629,
lArr: 8656,
uArr: 8657,
rArr: 8658,
dArr: 8659,
hArr: 8660,
forall: 8704,
part: 8706,
exist: 8707,
empty: 8709,
nabla: 8711,
isin: 8712,
notin: 8713,
ni: 8715,
prod: 8719,
sum: 8721,
minus: 8722,
lowast: 8727,
radic: 8730,
prop: 8733,
infin: 8734,
ang: 8736,
and: 8743,
or: 8744,
cap: 8745,
cup: 8746,
int: 8747,
there4: 8756,
sim: 8764,
cong: 8773,
asymp: 8776,
ne: 8800,
equiv: 8801,
le: 8804,
ge: 8805,
sub: 8834,
sup: 8835,
nsub: 8836,
sube: 8838,
supe: 8839,
oplus: 8853,
otimes: 8855,
perp: 8869,
sdot: 8901,
lceil: 8968,
rceil: 8969,
lfloor: 8970,
rfloor: 8971,
lang: 9001,
rang: 9002,
loz: 9674,
spades: 9824,
clubs: 9827,
hearts: 9829,
diams: 9830
};
const PathArguments = {
A: 7,
a: 7,
C: 6,
c: 6,
H: 1,
h: 1,
L: 2,
l: 2,
M: 2,
m: 2,
Q: 4,
q: 4,
S: 4,
s: 4,
T: 2,
t: 2,
V: 1,
v: 1,
Z: 0,
z: 0
};
const PathFlags = {
A3: true,
A4: true,
a3: true,
a4: true
};
const Properties = {
'color': {
inherit: true,
initial: undefined
},
'visibility': {
inherit: true,
initial: 'visible',
values: {
'hidden': 'hidden',
'collapse': 'hidden',
'visible': 'visible'
}
},
'fill': {
inherit: true,
initial: DefaultColors.black
},
'stroke': {
inherit: true,
initial: 'none'
},
'stop-color': {
inherit: false,
initial: DefaultColors.black
},
'fill-opacity': {
inherit: true,
initial: 1
},
'stroke-opacity': {
inherit: true,
initial: 1
},
'stop-opacity': {
inherit: false,
initial: 1
},
'fill-rule': {
inherit: true,
initial: 'nonzero',
values: {
'nonzero': 'nonzero',
'evenodd': 'evenodd'
}
},
'clip-rule': {
inherit: true,
initial: 'nonzero',
values: {
'nonzero': 'nonzero',
'evenodd': 'evenodd'
}
},
'stroke-width': {
inherit: true,
initial: 1
},
'stroke-dasharray': {
inherit: true,
initial: []
},
'stroke-dashoffset': {
inherit: true,
initial: 0
},
'stroke-miterlimit': {
inherit: true,
initial: 4
},
'stroke-linejoin': {
inherit: true,
initial: 'miter',
values: {
'miter': 'miter',
'round': 'round',
'bevel': 'bevel'
}
},
'stroke-linecap': {
inherit: true,
initial: 'butt',
values: {
'butt': 'butt',
'round': 'round',
'square': 'square'
}
},
'font-size': {
inherit: true,
initial: 16,
values: {
'xx-small': 9,
'x-small': 10,
'small': 13,
'medium': 16,
'large': 18,
'x-large': 24,
'xx-large': 32
}
},
'font-family': {
inherit: true,
initial: 'sans-serif'
},
'font-weight': {
inherit: true,
initial: 'normal',
values: {
'600': 'bold',
'700': 'bold',
'800': 'bold',
'900': 'bold',
'bold': 'bold',
'bolder': 'bold',
'500': 'normal',
'400': 'normal',
'300': 'normal',
'200': 'normal',
'100': 'normal',
'normal': 'normal',
'lighter': 'normal'
}
},
'font-style': {
inherit: true,
initial: 'normal',
values: {
'italic': 'italic',
'oblique': 'italic',
'normal': 'normal'
}
},
'text-anchor': {
inherit: true,
initial: 'start',
values: {
'start': 'start',
'middle': 'middle',
'end': 'end'
}
},
'direction': {
inherit: true,
initial: 'ltr',
values: {
'ltr': 'ltr',
'rtl': 'rtl'
}
},
'dominant-baseline': {
inherit: true,
initial: 'baseline',
values: {
'auto': 'baseline',
'baseline': 'baseline',
'before-edge': 'before-edge',
'text-before-edge': 'before-edge',
'middle': 'middle',
'central': 'central',
'after-edge': 'after-edge',
'text-after-edge': 'after-edge',
'ideographic': 'ideographic',
'alphabetic': 'alphabetic',
'hanging': 'hanging',
'mathematical': 'mathematical'
}
},
'alignment-baseline': {
inherit: false,
initial: undefined,
values: {
'auto': 'baseline',
'baseline': 'baseline',
'before-edge': 'before-edge',
'text-before-edge': 'before-edge',
'middle': 'middle',
'central': 'central',
'after-edge': 'after-edge',
'text-after-edge': 'after-edge',
'ideographic': 'ideographic',
'alphabetic': 'alphabetic',
'hanging': 'hanging',
'mathematical': 'mathematical'
}
},
'baseline-shift': {
inherit: true,
initial: 'baseline',
values: {
'baseline': 'baseline',
'sub': 'sub',
'super': 'super'
}
},
'word-spacing': {
inherit: true,
initial: 0,
values: {
normal: 0
}
},
'letter-spacing': {
inherit: true,
initial: 0,
values: {
normal: 0
}
},
'text-decoration': {
inherit: false,
initial: 'none',
values: {
'none': 'none',
'underline': 'underline',
'overline': 'overline',
'line-through': 'line-through'
}
},
'xml:space': {
inherit: true,
initial: 'default',
css: 'white-space',
values: {
'preserve': 'preserve',
'default': 'default',
'pre': 'preserve',
'pre-line': 'preserve',
'pre-wrap': 'preserve',
'nowrap': 'default'
}
},
'marker-start': {
inherit: true,
initial: 'none'
},
'marker-mid': {
inherit: true,
initial: 'none'
},
'marker-end': {
inherit: true,
initial: 'none'
},
'opacity': {
inherit: false,
initial: 1
},
'transform': {
inherit: false,
initial: [1, 0, 0, 1, 0, 0]
},
'display': {
inherit: false,
initial: 'inline',
values: {
'none': 'none',
'inline': 'inline',
'block': 'inline'
}
},
'clip-path': {
inherit: false,
initial: 'none'
},
'mask': {
inherit: false,
initial: 'none'
},
'overflow': {
inherit: false,
initial: 'hidden',
values: {
'hidden': 'hidden',
'scroll': 'hidden',
'visible': 'visible'
}
},
'vector-effect': {
inherit: true,
initial: 'none',
values: {
'none': 'none',
'non-scaling-stroke': 'non-scaling-stroke'
}
}
};
function docBeginGroup(bbox) {
let group = new function PDFGroup() {}();
group.name = 'G' + (doc._groupCount = (doc._groupCount || 0) + 1);
group.resources = doc.ref();
group.xobj = doc.ref({
Type: 'XObject',
Subtype: 'Form',
FormType: 1,
BBox: bbox,
Group: {
S: 'Transparency',
CS: 'DeviceRGB',
I: true,
K: false
},
Resources: group.resources
});
group.xobj.write('');
group.savedMatrix = doc._ctm;
group.savedPage = doc.page;
groupStack.push(group);
doc._ctm = [1, 0, 0, 1, 0, 0];
doc.page = {
width: doc.page.width,
height: doc.page.height,
write: function (data) {
group.xobj.write(data);
},
fonts: {},
xobjects: {},
ext_gstates: {},
patterns: {}
};
return group;
}
function docEndGroup(group) {
if (group !== groupStack.pop()) {
throw 'Group not matching';
}
if (Object.keys(doc.page.fonts).length) {
group.resources.data.Font = doc.page.fonts;
}
if (Object.keys(doc.page.xobjects).length) {
group.resources.data.XObject = doc.page.xobjects;
}
if (Object.keys(doc.page.ext_gstates).length) {
group.resources.data.ExtGState = doc.page.ext_gstates;
}
if (Object.keys(doc.page.patterns).length) {
group.resources.data.Pattern = doc.page.patterns;
}
group.resources.end();
group.xobj.end();
doc._ctm = group.savedMatrix;
doc.page = group.savedPage;
}
function docInsertGroup(group) {
doc.page.xobjects[group.name] = group.xobj;
doc.addContent('/' + group.name + ' Do');
}
function docApplyMask(group, clip) {
let name = 'M' + (doc._maskCount = (doc._maskCount || 0) + 1);
let gstate = doc.ref({
Type: 'ExtGState',
CA: 1,
ca: 1,
BM: 'Normal',
SMask: {
S: 'Luminosity',
G: group.xobj,
BC: clip ? [0, 0, 0] : [1, 1, 1]
}
});
gstate.end();
doc.page.ext_gstates[name] = gstate;
doc.addContent('/' + name + ' gs');
}
function docCreatePattern(group, dx, dy, matrix) {
let pattern = {
type: 'PDFPattern',
group: group,
dx: dx,
dy: dy,
matrix: matrix || [1, 0, 0, 1, 0, 0]
};
return pattern;
}
function docUsePattern(pattern, stroke) {
let name = 'P' + (doc._patternCount = (doc._patternCount || 0) + 1);
let ref = doc.ref({
Type: 'Pattern',
PatternType: 1,
PaintType: 1,
TilingType: 2,
BBox: [0, 0, pattern.dx, pattern.dy],
XStep: pattern.dx,
YStep: pattern.dy,
Matrix: multiplyMatrix(doc._ctm, pattern.matrix),
Resources: {
ProcSet: ['PDF', 'Text', 'ImageB', 'ImageC', 'ImageI'],
XObject: function () {
let temp = {};
temp[pattern.group.name] = pattern.group.xobj;
return temp;
}()
}
});
ref.write('/' + pattern.group.name + ' Do');
ref.end();
doc.page.patterns[name] = ref;
if (stroke) {
doc.addContent('/Pattern CS');
doc.addContent('/' + name + ' SCN');
} else {
doc.addContent('/Pattern cs');
doc.addContent('/' + name + ' scn');
}
}
function docBeginText(font, size) {
if (!doc.page.fonts[font.id]) {
doc.page.fonts[font.id] = font.ref();
}
doc.addContent('BT').addContent('/' + font.id + ' ' + size + ' Tf');
}
function docSetTextMatrix(a, b, c, d, e, f) {
doc.addContent(validateNumber(a) + ' ' + validateNumber(b) + ' ' + validateNumber(-c) + ' ' + validateNumber(-d) + ' ' + validateNumber(e) + ' ' + validateNumber(f) + ' Tm');
}
function docSetTextMode(fill, stroke) {
let mode = fill && stroke ? 2 : stroke ? 1 : fill ? 0 : 3;
doc.addContent(mode + ' Tr');
}
function docWriteGlyphs(positions, font) {
let commands = [];
let commandStr = '';
const skew = font.fauxItalic ? -0.25 : 0;
// Add the given character to the 'TJ' command string.
function addChar(char) {
commandStr += char.glyph;
if (char.kern === 0) return;
commands.push(`<${commandStr}> ${validateNumber(char.kern)}`);
commandStr = '';
}
;
// Flush the current TJ command string to the output stream.
function flush() {
if (commandStr.length) {
commands.push(`<${commandStr}> 0`);
commandStr = '';
}
if (commands.length) {
doc.addContent(`[${commands.join(' ')}] TJ`);
commands = [];
}
}
;
for (let i = 0; i < positions.length; i++) {
const pos = positions[i];
if (pos.hidden || isEqual(pos.width, 0)) {
flush();
continue;
}
if (pos.continuous) {
addChar(pos);
continue;
}
// If this character is non-continuous, flush the command buffer.
flush();
// Start a new TJ command after writing a Text Matrix (Tm)
const cos = Math.cos(pos.rotate);
const sin = Math.sin(pos.rotate);
docSetTextMatrix(cos * pos.scale, sin * pos.scale, cos * skew - sin, sin * skew + cos, pos.x, pos.y);
addChar(pos);
}
;
// Flush any remaining characters in the buffer.
flush();
}
function docEndText() {
doc.addContent('ET');
}
function docFillColor(color) {
if (color[0].type === 'PDFPattern') {
doc.fillOpacity(color[1]);
docUsePattern(color[0], false);
} else {
doc.fillColor(color[0], color[1]);
}
}
function docStrokeColor(color) {
if (color[0].type === 'PDFPattern') {
doc.strokeOpacity(color[1]);
docUsePattern(color[0], true);
} else {
doc.strokeColor(color[0], color[1]);
}
}
// PDFKit doesn't accept any 0s in the dash array, but that's perfectly
// valid in SVG. So this function applys a dash array and offset, detecting
// any 0s in the dash array and updating it and the dash offset as needed to
// remove the zeros, but preserve the end result.
//
// `dashArray` must have an even number of elements
function docApplyDash(dashArray, dashOffset) {
let index;
// Anytime there's a 0 that isn't the first or last element of the array,
// we can remove it by combining the previous or next value. If it's a
// dash, then it's a zero-length dash between two spaces, so the dash can
// be eliminated and spaces combined by summing them, replacing all three
// values with the sum of the two spaces. If the 0 value is a space, then
// it's a zero-length space between two dashes, and the dashes can be
// similarly combined. So first we run that logic iteratively to remove
// all the 0s from the dash array that aren't the first or last element.
// Note that because we replace 3 values with one value, this doesn't
// change the even-ness of the length of dashArray.
while ((index = dashArray.slice(1, -1).indexOf(0)) !== -1) {
let actualIndex = index + 1;
let replacementValue = dashArray[actualIndex - 1] + dashArray[actualIndex + 1];
dashArray = dashArray.slice(0, actualIndex - 1).concat([replacementValue]).concat(dashArray.slice(actualIndex + 2));
}
// The stroke array only having two elements (a dash value and space
// value) is a special case.
if (dashArray.length === 2) {
if (dashArray[0] === 0) {
// Regardless of the space value, the dash length is zero, so we're
// not actually drawing a stroke. We can't describe that in a
// doc.dash() call in a way that PDFKit will accept, so we set the
// stroke opacity to zero as our best approximation.
doc.strokeOpacity(0);
return;
} else if (dashArray[1] === 0) {
// Regardless of the dash value, the space value is zero, meaning
// we're actually drawing a solid stroke, not a dashed one. We can
// make this happen by just emptying out the dash array.
dashArray = [];
}
} else {
if (dashArray[0] === 0) {
// The first dash is zero-length. We fix this by combining the first
// space (just after the first dash) with the last space and updating
// the dash offset accordingly. For example, if we had
//
// [ 0 4 3 2 5 1 ] (dash offset 0)
//
// ␣␣␣␣---␣␣-----␣
// ⎸
//
// we'd end up with
//
// [ 3 2 5 5 ] (dash offset -4)
//
// ---␣␣-----␣␣␣␣␣
// ⎸
//
// Another example where the dash array also ends with a 0:
//
// [ 0 4 3 2 5 0 ] (dash offset 0)
//
// ␣␣␣␣---␣␣-----
// ⎸
//
// we'd end up with
//
// [ 3 2 5 4 ] (dash offset -4)
//
// ---␣␣-----␣␣␣␣
// ⎸
dashOffset -= dashArray[1];
dashArray[dashArray.length - 1] += dashArray[1];
dashArray = dashArray.slice(2);
}
if (dashArray[dashArray.length - 1] === 0) {
// The last space is zero-length. We fix this by combining the last dash
// (just before the last space) with the first dash and updating the
// dash offset accordingly. For example, if we had
//
// [ 1 4 3 2 5 0 ] (dash offset 0)
//
// -␣␣␣␣---␣␣-----
// ⎸
//
// we'd end up with
//
// [ 6 4 3 2 ] (dash offset 5)
//
// ------␣␣␣␣---␣␣
// ⎸
//
dashOffset += dashArray[dashArray.length - 2];
dashArray[0] += dashArray[dashArray.length - 2];
dashArray = dashArray.slice(0, -2);
}
}
// Ensure the dash offset is non-negative (because of crbug.com/660850).
// First compute the total length of the dash array so we can add it to
// dash offset until dash offset is non-negative.
let length = 0;
for (let i = 0; i < dashArray.length; i++) {
length += dashArray[i];
}
if (length > 0) {
while (dashOffset < 0) {
dashOffset += length;
}
}
doc.dash(dashArray, {
phase: dashOffset
});
}
function docInsertLink(x, y, w, h, url) {
let ref = doc.ref({
Type: 'Annot',
Subtype: 'Link',
Rect: [x, y, w, h],
Border: [0, 0, 0],
A: {
S: 'URI',
URI: new String(url)
}
});
ref.end();
links.push(ref);
}
function parseXml(xml) {
let SvgNode = function (tag, type, value, error) {
this.error = error;
this.nodeName = tag;
this.nodeValue = value;
this.nodeType = type;
this.attributes = Object.create(null);
this.childNodes = [];
this.parentNode = null;
this.id = '';
this.textContent = '';
this.classList = [];
};
SvgNode.prototype.getAttribute = function (attr) {
return this.attributes[attr] != null ? this.attributes[attr] : null;
};
SvgNode.prototype.getElementById = function (id) {
let result = null;
(function recursive(node) {
if (result) {
return;
}
if (node.nodeType === 1) {
if (node.id === id) {
result = node;
}
for (let i = 0; i < node.childNodes.length; i++) {
recursive(node.childNodes[i]);
}
}
})(this);
return result;
};
SvgNode.prototype.getElementsByTagName = function (tag) {
let result = [];
(function recursive(node) {
if (node.nodeType === 1) {
if (node.nodeName === tag) {
result.push(node);
}
for (let i = 0; i < node.childNodes.length; i++) {
recursive(node.childNodes[i]);
}
}
})(this);
return result;
};
let parser = new StringParser(xml.trim()),
result,
child,
error = false;
let recursive = function () {
let temp, child;
if (temp = parser.match(/^<([\w:.-]+)\s*/, true)) {
// Opening tag
let node = new SvgNode(temp[1], 1, null, error);
while (temp = parser.match(/^([\w:.-]+)(?:\s*=\s*"([^"]*)"|\s*=\s*'([^']*)')?\s*/, true)) {
// Attribute
let attr = temp[1],
value = decodeEntities(temp[2] || temp[3] || '');
if (!node.attributes[attr]) {
node.attributes[attr] = value;
if (attr === 'id') {
node.id = value;
}
if (attr === 'class') {
node.classList = value.split(' ');
}
} else {
warningCallback('parseXml: duplicate attribute "' + attr + '"');
error = true;
}
}
if (parser.match(/^>/)) {
// End of opening tag
while (child = recursive()) {
node.childNodes.push(child);
child.parentNode = node;
node.textContent += child.nodeType === 3 || child.nodeType === 4 ? child.nodeValue : child.textContent;
}
if (temp = parser.match(/^<\/([\w:.-]+)\s*>/, true)) {
// Closing tag
if (temp[1] === node.nodeName) {
return node;
} else {
warningCallback('parseXml: tag not matching, opening "' + node.nodeName + '" & closing "' + temp[1] + '"');
error = true;
return node;
}
} else {
warningCallback('parseXml: tag not matching, opening "' + node.nodeName + '" & not closing');
error = true;
return node;
}
} else if (parser.match(/^\/>/)) {
// Self-closing tag
return node;
} else {
warningCallback('parseXml: tag could not be parsed "' + node.nodeName + '"');
error = true;
}
} else if (temp = parser.match(/^<!--[\s\S]*?-->/)) {
// Comment
return new SvgNode(null, 8, temp, error);
} else if (temp = parser.match(/^<\?[\s\S]*?\?>/)) {
// Processing instructions
return new SvgNode(null, 7, temp, error);
} else if (temp = parser.match(/^<!DOCTYPE\s*([\s\S]*?)>/)) {
// Doctype
return new SvgNode(null, 10, temp, error);
} else if (temp = parser.match(/^<!\[CDATA\[([\s\S]*?)\]\]>/, true)) {
// Cdata node
return new SvgNode('#cdata-section', 4, temp[1], error);
} else if (temp = parser.match(/^([^<]+)/, true)) {
// Text node
return new SvgNode('#text', 3, decodeEntities(temp[1]), error);
}
};
while (child = recursive()) {
if (child.nodeType === 1 && !result) {
result = child;
} else if (child.nodeType === 1 || child.nodeType === 3 && child.nodeValue.trim() !== '') {
warningCallback('parseXml: data after document end has been discarded');
}
}
if (parser.matchAll()) {
warningCallback('parseXml: parsing error');
}
return result;
}
;
function decodeEntities(str) {
return str.replace(/&(?:#([0-9]+)|#[xX]([0-9A-Fa-f]+)|([0-9A-Za-z]+));/g, function (mt, m0, m1, m2) {
if (m0) {
return String.fromCharCode(parseInt(m0, 10));
} else if (m1) {
return String.fromCharCode(parseInt(m1, 16));
} else if (m2 && Entities[m2]) {
return String.fromCharCode(Entities[m2]);
} else {
return mt;
}
});
}
function parseColor(raw) {
let temp, result;
raw = (raw || '').trim();
if (temp = NamedColors[raw]) {
result = [temp.slice(), 1];
} else if (temp = raw.match(/^cmyk\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9.]+)\s*\)$/i)) {
temp[1] = parseInt(temp[1]);
temp[2] = parseInt(temp[2]);
temp[3] = parseInt(temp[3]);
temp[4] = parseFloat(temp[4]);
if (temp[1] <= 100 && temp[2] <= 100 && temp[3] <= 100 && temp[4] <= 100) {
result = [temp.slice(1, 5), 1];
}
} else if (temp = raw.match(/^rgba\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9.]+)\s*\)$/i)) {
temp[1] = parseInt(temp[1]);
temp[2] = parseInt(temp[2]);
temp[3] = parseInt(temp[3]);
temp[4] = parseFloat(temp[4]);
if (temp[1] < 256 && temp[2] < 256 && temp[3] < 256 && temp[4] <= 1) {
result = [temp.slice(1, 4), temp[4]];
}
} else if (temp = raw.match(/^rgb\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*\)$/i)) {
temp[1] = parseInt(temp[1]);
temp[2] = parseInt(temp[2]);
temp[3] = parseInt(temp[3]);
if (temp[1] < 256 && temp[2] < 256 && temp[3] < 256) {
result = [temp.slice(1, 4), 1];
}
} else if (temp = raw.match(/^rgb\(\s*([0-9.]+)%\s*,\s*([0-9.]+)%\s*,\s*([0-9.]+)%\s*\)$/i)) {
temp[1] = 2.55 * parseFloat(temp[1]);
temp[2] = 2.55 * parseFloat(temp[2]);
temp[3] = 2.55 * parseFloat(temp[3]);
if (temp[1] < 256 && temp[2] < 256 && temp[3] < 256) {
result = [temp.slice(1, 4), 1];
}
} else if (temp = raw.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i)) {
result = [[parseInt(temp[1], 16), parseInt(temp[2], 16), parseInt(temp[3], 16)], 1];
} else if (temp = raw.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/i)) {
result = [[0x11 * parseInt(temp[1], 16), 0x11 * parseInt(temp[2], 16), 0x11 * parseInt(temp[3], 16)], 1];
}
return colorCallback ? colorCallback(result, raw) : result;
}
function opacityToColor(color, opacity, isMask) {
let newColor = color[0].slice(),
newOpacity = color[1] * opacity;
if (isMask) {
for (let i = 0; i < color.length; i++) {
newColor[i] *= newOpacity;
}
return [newColor, 1];
} else {
return [newColor, newOpacity];
}
}
function multiplyMatrix() {
function multiply(a, b) {
return [a[0] * b[0] + a[2] * b[1], a[1] * b[0] + a[3] * b[1], a[0] * b[2] + a[2] * b[3], a[1] * b[2] + a[3] * b[3], a[0] * b[4] + a[2] * b[5] + a[4], a[1] * b[4] + a[3] * b[5] + a[5]];
}
let result = arguments[0];
for (let i = 1; i < arguments.length; i++) {
result = multiply(result, arguments[i]);
}
return result;
}
function transformPoint(p, m) {
return [m[0] * p[0] + m[2] * p[1] + m[4], m[1] * p[0] + m[3] * p[1] + m[5]];
}
function getGlobalMatrix() {
let ctm = doc._ctm;
for (let i = groupStack.length - 1; i >= 0; i--) {
ctm = multiplyMatrix(groupStack[i].savedMatrix, ctm);
}
return ctm;
}
function getPageBBox() {
return new SvgShape().M(0, 0).L(doc.page.width, 0).L(doc.page.width, doc.page.height).L(0, doc.page.height).transform(inverseMatrix(getGlobalMatrix())).getBoundingBox();
}
function getPageScale() {
const bbox = getPageBBox();
const width = doc.page.width;
return width / bbox[2];
}
function inverseMatrix(m) {
let dt = m[0] * m[3] - m[1] * m[2];
return [m[3] / dt, -m[1] / dt, -m[2] / dt, m[0] / dt, (m[2] * m[5] - m[3] * m[4]) / dt, (m[1] * m[4] - m[0] * m[5]) / dt];
}
function validateMatrix(m) {
let m0 = validateNumber(m[0]),
m1 = validateNumber(m[1]),
m2 = validateNumber(m[2]),
m3 = validateNumber(m[3]),
m4 = validateNumber(m[4]),
m5 = validateNumber(m[5]);
if (isNotEqual(m0 * m3 - m1 * m2, 0)) {
return [m0, m1, m2, m3, m4, m5];
}
}
function solveEquation(curve) {
let a = curve[2] || 0,
b = curve[1] || 0,
c = curve[0] || 0;
if (isEqual(a, 0) && isEqual(b, 0)) {
return [];
} else if (isEqual(a, 0)) {
return [-c / b];
} else {
let d = b * b - 4 * a * c;
if (isNotEqual(d, 0) && d > 0) {
return [(-b + Math.sqrt(d)) / (2 * a), (-b - Math.sqrt(d)) / (2 * a)];
} else if (isEqual(d, 0)) {
return [-b / (2 * a)];
} else {
return [];
}
}
}
function getCurveValue(t, curve) {
return (curve[0] || 0) + (curve[1] || 0) * t + (curve[2] || 0) * t * t + (curve[3] || 0) * t * t * t;
}
function isEqual(number, ref) {
return Math.abs(number - ref) < 1e-10;
}
function isNotEqual(number, ref) {
return Math.abs(number - ref) >= 1e-10;
}
function validateNumber(n) {
return n > -1e21 && n < 1e21 ? Math.round(n * 1e6) / 1e6 : 0;
}
function isArrayLike(v) {
return typeof v === 'object' && v !== null && typeof v.length === 'number';
}
function parseTranform(v) {
let parser = new StringParser((v || '').trim()),
result = [1, 0, 0, 1, 0, 0],
temp;
while (temp = parser.match(/^([A-Za-z]+)\s*[(]([^(]+)[)]/, true)) {
let func = temp[1],
nums = [],
parser2 = new StringParser(temp[2].trim()),
temp2;
while (temp2 = parser2.matchNumber()) {
nums.push(Number(temp2));
parser2.matchSeparator();
}
if (func === 'matrix' && nums.length === 6) {
result = multiplyMatrix(result, [nums[0], nums[1], nums[2], nums[3], nums[4], nums[5]]);
} else if (func === 'translate' && nums.length === 2) {
result = multiplyMatrix(result, [1, 0, 0, 1, nums[0], nums[1]]);
} else if (func === 'translate' && nums.length === 1) {
result = multiplyMatrix(result, [1, 0, 0, 1, nums[0], 0]);
} else if (func === 'scale' && nums.length === 2) {
result = multiplyMatrix(result, [nums[0], 0, 0, nums[1], 0, 0]);
} else if (func === 'scale' && nums.length === 1) {
result = multiplyMatrix(result, [nums[0], 0, 0, nums[0], 0, 0]);
} else if (func === 'rotate' && nums.length === 3) {
let a = nums[0] * Math.PI / 180;
result = multiplyMatrix(result, [1, 0, 0, 1, nums[1], nums[2]], [Math.cos(a), Math.sin(a), -Math.sin(a), Math.cos(a), 0, 0], [1, 0, 0, 1, -nums[1], -nums[2]]);
} else if (func === 'rotate' && nums.length === 1) {
let a = nums[0] * Math.PI / 180;
result = multiplyMatrix(result, [Math.cos(a), Math.sin(a), -Math.sin(a), Math.cos(a), 0, 0]);
} else if (func === 'skewX' && nums.length === 1) {
let a = nums[0] * Math.PI / 180;
result = multiplyMatrix(result, [1, 0, Math.tan(a), 1, 0, 0]);
} else if (func === 'skewY' && nums.length === 1) {
let a = nums[0] * Math.PI / 180;
result = multiplyMatrix(result, [1, Math.tan(a), 0, 1, 0, 0]);
} else {
return;
}
parser.matchSeparator();
}
if (parser.matchAll()) {
return;
}
return result;
}
function parseAspectRatio(aspectRatio, availWidth, availHeight, elemWidth, elemHeight, initAlign) {
let temp = (aspectRatio || '').trim().match(/^(none)$|^x(Min|Mid|Max)Y(Min|Mid|Max)(?:\s+(meet|slice))?$/) || [],
ratioType = temp[1] || temp[4] || 'meet',
xAlign = temp[2] || 'Mid',
yAlign = temp[3] || 'Mid',
scaleX = availWidth / elemWidth,
scaleY = availHeight / elemHeight,
dx = {
'Min': 0,
'Mid': 0.5,
'Max': 1
}[xAlign] - (initAlign || 0),
dy = {
'Min': 0,
'Mid': 0.5,
'Max': 1
}[yAlign] - (initAlign || 0);
if (ratioType === 'slice') {
scaleY = scaleX = Math.max(scaleX, scaleY);
} else if (ratioType === 'meet') {
scaleY = scaleX = Math.min(scaleX, scaleY);
}
return [scaleX, 0, 0, scaleY, dx * (availWidth - elemWidth * scaleX), dy * (availHeight - elemHeight * scaleY)];
}
function parseStyleAttr(v) {
let result = Object.create(null);
v = (v || '').trim().split(/;/);
for (let i = 0; i < v.length; i++) {
let key = (v[i].split(':')[0] || '').trim(),
value = (v[i].split(':')[1] || '').trim();
if (key) {
result[key] = value;
}
}
if (result['marker']) {
if (!result['marker-start']) {
result['marker-start'] = result['marker'];
}
if (!result['marker-mid']) {
result['marker-mid'] = result['marker'];
}
if (!result['marker-end']) {
result['marker-end'] = result['marker'];
}
}
if (result['font']) {
let fontFamily = null,
fontSize = null,
fontStyle = "normal",
fontWeight = "normal",
fontVariant = "normal";
let parts = result['font'].split(/\s+/);
for (let i = 0; i < parts.length; i++) {
switch (parts[i]) {
case "normal":
break;
case "italic":
case "oblique":
fontStyle = parts[i];
break;
case "small-caps":
fontVariant = parts[i];
break;
case "bold":
case "bolder":
case "lighter":
case "100":
case "200":
case "300":
case "400":
case "500":
case "600":
case "700":
case "800":
case "900":
fontWeight = parts[i];
break;
default:
if (!fontSize) {
fontSize = parts[i].split('/')[0];
} else {
if (!fontFamily) {
fontFamily = parts[i];
} else {
fontFamily += ' ' + parts[i];
}
}
break;
}
}
if (!result['font-style']) {
result['font-style'] = fontStyle;
}
if (!result['font-variant']) {
result['font-variant'] = fontVariant;
}
if (!result['font-weight']) {
result['font-weight'] = fontWeight;
}
if (!result['font-size']) {
result['font-size'] = fontSize;
}
if (!result['font-family']) {
result['font-family'] = fontFamily;
}
}
return result;
}
function parseSelector(v) {
let parts = v.split(/(?=[.#])/g),
ids = [],
classes = [],
tags = [],
temp;
for (let i = 0; i < parts.length; i++) {
if (temp = parts[i].match(/^[#]([_A-Za-z0-9-]+)$/)) {
ids.push(temp[1]);
} else if (temp = parts[i].match(/^[.]([_A-Za-z0-9-]+)$/)) {
classes.push(temp[1]);
} else if (temp = parts[i].match(/^([_A-Za-z0-9-]+)$/)) {
tags.push(temp[1]);
} else if (parts[i] !== '*') {
return;
}
}
return {
tags: tags,
ids: ids,
classes: classes,
specificity: ids.length * 10000 + classes.length * 100 + tags.length
};
}
function parseStyleSheet(v) {
let parser = new StringParser(v.trim()),
rules = [],
rule;
while (rule = parser.match(/^\s*([^\{\}]*?)\s*\{([^\{\}]*?)\}/, true)) {
let selectors = rule[1].split(/\s*,\s*/g),
css = parseStyleAttr(rule[2]);
for (let i = 0; i < selectors.length; i++) {
let selector = parseSelector(selectors[i]);
if (selector) {
rules.push({
selector: selector,
css: css
});
}
}
}
return rules;
}
function matchesSelector(elem, selector) {
if (elem.nodeType !== 1) {
return false;
}
for (let i = 0; i < selector.tags.length; i++) {
if (selector.tags[i] !== elem.nodeName) {
return false;
}
}
for (let i = 0; i < selector.ids.length; i++) {
if (selector.ids[i] !== elem.id) {
return false;
}
}
for (let i = 0; i < selector.classes.length; i++) {
if (elem.classList.indexOf(selector.classes[i]) === -1) {
return false;
}
}
return true;
}
function getStyle(elem) {
let result = Object.create(null);
let specificities = Object.create(null);
for (let i = 0; i < styleRules.length; i++) {
let rule = styleRules[i];
if (matchesSelector(elem, rule.selector)) {
for (let key in rule.css) {
if (!(specificities[key] > rule.selector.specificity)) {
result[key] = rule.css[key];
specificities[key] = rule.selector.specificity;
}
}
}
}
return result;
}
function combineArrays(array1, array2) {
return array1.concat(array2.slice(array1.length));
}
function getAscent(font, size) {
return Math.max(font.ascender, (font.bbox[3] || font.bbox.maxY) * (font.scale || 1)) * size / 1000;
}
function getDescent(font, size) {
return Math.min(font.descender, (font.bbox[1] || font.bbox.minY) * (font.scale || 1)) * size / 1000;
}
function getXHeight(font, size) {
return (font.xHeight || 0.5 * (font.ascender - font.descender)) * size / 1000;
}
function getBaseline(font, size, baseline, shift) {
let dy1, dy2;
switch (baseline) {
case 'middle':
dy1 = 0.5 * getXHeight(font, size);
break;
case 'central':
dy1 = 0.5 * (getDescent(font, size) + getAscent(font, size));
break;
case 'after-edge':
case 'text-after-edge':
dy1 = getDescent(font, size);
break;
case 'alphabetic':
case 'auto':
case 'baseline':
dy1 = 0;
break;
case 'mathematical':
dy1 = 0.5 * getAscent(font, size);
break;
case 'hanging':
dy1 = 0.8 * getAscent(font, size);
break;
case 'before-edge':
case 'text-before-edge':
dy1 = getAscent(font, size);
break;
default:
dy1 = 0;
break;
}
switch (shift) {
case 'baseline':
dy2 = 0;
break;
case 'super':
dy2 = 0.6 * size;
break;
case 'sub':
dy2 = -0.6 * size;
break;
default:
dy2 = shift;
break;
}
return dy1 - dy2;
}
function getTextPos(font, size, text) {
let encoded = font.encode('' + text),
hex = encoded[0],
pos = encoded[1],
data = [];
for (let i = 0; i < hex.length; i++) {
let unicode = font.unicode ? font.unicode[parseInt(hex[i], 16)] : [text.charCodeAt(i)];
data.push({
glyph: hex[i],
unicode: unicode,
kern: pos[i].advanceWidth - pos[i].xAdvance,
width: pos[i].advanceWidth * size / 1000,
xOffset: pos[i].xOffset * size / 1000,
yOffset: pos[i].yOffset * size / 1000,
xAdvance: pos[i].xAdvance * size / 1000,
yAdvance: pos[i].yAdvance * size / 1000
});
}
return data;
}
function createSVGElement(obj, inherits) {
switch (obj.nodeName) {
case 'use':
return new SvgElemUse(obj, inherits);
case 'symbol':
return new SvgElemSymbol(obj, inherits);
case 'g':
return new SvgElemGroup(obj, inherits);
case 'a':
return new SvgElemLink(obj, inherits);
case 'svg':
return new SvgElemSvg(obj, inherits);
case 'image':
return new SVGElemImage(obj, inherits);
case 'rect':
return new SvgElemRect(obj, inherits);
case 'circle':
return new SvgElemCircle(obj, inherits);
case 'ellipse':
return new SvgElemEllipse(obj, inherits);
case 'line':
return new SvgElemLine(obj, inherits);
case 'polyline':
return new SvgElemPolyline(obj, inherits);
case 'polygon':
return new SvgElemPolygon(obj, inherits);
case 'path':
return new SvgElemPath(obj, inherits);
case 'text':
return new SvgElemText(obj, inherits);
case 'tspan':
return new SvgElemTspan(obj, inherits);
case 'textPath':
return new SvgElemTextPath(obj, inherits);
case '#text':
case '#cdata-section':
return new SvgElemTextNode(obj, inherits);
default:
return new SvgElem(obj, inherits);
}
}
var StringParser = function (str) {
this.match = function (exp, all) {
let temp = str.match(exp);
if (!temp || temp.index !== 0) {
return;
}
str = str.substring(temp[0].length);
return all ? temp : temp[0];
};
this.matchSeparator = function () {
return this.match(/^(?:\s*,\s*|\s*|)/);
};
this.matchSpace = function () {
return this.match(/^(?:\s*)/);
};
this.matchLengthUnit = function () {
return this.match(/^(?:px|pt|cm|mm|in|pc|em|ex|%|)/);
};
this.matchNumber = function () {
return this.match(/^(?:[-+]?(?:[0-9]+[.][0-9]+|[0-9]+[.]|[.][0-9]+|[0-9]+)(?:[eE][-+]?[0-9]+)?)/);
};
this.matchAll = function () {
return this.match(/^[\s\S]+/);
};
};
var BezierSegment = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {
let divisions = 6 * precision;
let equationX = [p1x, -3 * p1x + 3 * c1x, 3 * p1x - 6 * c1x + 3 * c2x, -p1x + 3 * c1x - 3 * c2x + p2x];
let equationY = [p1y, -3 * p1y + 3 * c1y, 3 * p1y - 6 * c1y + 3 * c2y, -p1y + 3 * c1y - 3 * c2y + p2y];
let derivativeX = [-3 * p1x + 3 * c1x, 6 * p1x - 12 * c1x + 6 * c2x, -3 * p1x + 9 * c1x - 9 * c2x + 3 * p2x];
let derivativeY = [-3 * p1y + 3 * c1y, 6 * p1y - 12 * c1y + 6 * c2y, -3 * p1y + 9 * c1y - 9 * c2y + 3 * p2y];
let lengthMap = [0];
for (let i = 1; i <= divisions; i++) {
let t = (i - 0.5) / divisions;
let dx = getCurveValue(t, derivativeX) / divisions,
dy = getCurveValue(t, derivativeY) / divisions,
l = Math.sqrt(dx * dx + dy * dy);
lengthMap[i] = lengthMap[i - 1] + l;
}
this.totalLength = lengthMap[divisions];
this.startPoint = [p1x, p1y, isEqual(p1x, c1x) && isEqual(p1y, c1y) ? Math.atan2(c2y - c1y, c2x - c1x) : Math.atan2(c1y - p1y, c1x - p1x)];
this.endPoint = [p2x, p2y, isEqual(c2x, p2x) && isEqual(c2y, p2y) ? Math.atan2(c2y - c1y, c2x - c1x) : Math.atan2(p2y - c2y, p2x - c2x)];
this.getBoundingBox = function () {
let temp;
let minX = getCurveValue(0, equationX),
minY = getCurveValue(0, equationY),
maxX = getCurveValue(1, equationX),
maxY = getCurveValue(1, equationY);
if (minX > maxX) {
temp = maxX;
maxX = minX;
minX = temp;
}
if (minY > maxY) {
temp = maxY;
maxY = minY;
minY = temp;
}
let rootsX = solveEquation(derivativeX);
for (let i = 0; i < rootsX.length; i++) {
if (rootsX[i] >= 0 && rootsX[i] <= 1) {
let x = getCurveValue(rootsX[i], equationX);
if (x < minX) {
minX = x;
}
if (x > maxX) {
maxX = x;
}
}
}
let rootsY = solveEquation(derivativeY);
for (let i = 0; i < rootsY.length; i++) {
if (rootsY[i] >= 0 && rootsY[i] <= 1) {
let y = getCurveValue(rootsY[i], equationY);
if (y < minY) {
minY = y;
}
if (y > maxY) {
maxY = y;
}
}
}
return [minX, minY, maxX, maxY];
};
this.getPointAtLength = function (l) {
if (isEqual(l, 0)) {
return this.startPoint;
}
if (isEqual(l, this.totalLength)) {
return this.endPoint;
}
if (l < 0 || l > this.totalLength) {
return;
}
for (let i = 1; i <= divisions; i++) {
let l1 = lengthMap[i - 1],
l2 = lengthMap[i];
if (l1 <= l && l <= l2) {
let t = (i - (l2 - l) / (l2 - l1)) / divisions,
x = getCurveValue(t, equationX),
y = getCurveValue(t, equationY),
dx = getCurveValue(t, derivativeX),
dy = getCurveValue(t, derivativeY);
return [x, y, Math.atan2(dy, dx)];
}
}
};
};
var LineSegment = function (p1x, p1y, p2x, p2y) {
this.totalLength = Math.sqrt((p2x - p1x) * (p2x - p1x) + (p2y - p1y) * (p2y - p1y));
this.startPoint = [p1x, p1y, Math.atan2(p2y - p1y, p2x - p1x)];
this.endPoint = [p2x, p2y, Math.atan2(p2y - p1y, p2x - p1x)];
this.getBoundingBox = function () {
return [Math.min(this.startPoint[0], this.endPoint[0]), Math.min(this.startPoint[1], this.endPoint[1]), Math.max(this.startPoint[0], this.endPoint[0]), Math.max(this.startPoint[1], this.endPoint[1])];
};
this.getPointAtLength = function (l) {
if (l >= 0 && l <= this.totalLength) {
let r = l / this.totalLength || 0,
x = this.startPoint[0] + r * (this.endPoint[0] - this.startPoint[0]),
y = this.startPoint[1] + r * (this.endPoint[1] - this.startPoint[1]);
return [x, y, this.startPoint[2]];
}
};
};
var SvgShape = function () {
this.pathCommands = [];
this.pathSegments = [];
this.startPoint = null;
this.endPoint = null;
this.totalLength = 0;
let startX = 0,
startY = 0,
currX = 0,
currY = 0,
lastCom,
lastCtrlX,
lastCtrlY;
this.move = function (x, y) {
startX = currX = x;
startY = currY = y;
return null;
};
this.line = function (x, y) {
let segment = new LineSegment(currX, currY, x, y);
currX = x;
currY = y;
return segment;
};
this.curve = function (c1x, c1y, c2x, c2y, x, y) {
let segment = new BezierSegment(currX, currY, c1x, c1y, c2x, c2y, x, y);
currX = x;
currY = y;
return segment;
};
this.close = function () {
let segment = new LineSegment(currX, currY, startX, startY);
currX = startX;
currY = startY;
return segment;
};
this.addCommand = function (data) {
this.pathCommands.push(data);
let segment = this[data[0]].apply(this, data.slice(3));
if (segment) {
segment.hasStart = data[1];
segment.hasEnd = data[2];
this.startPoint = this.startPoint || segment.startPoint;
this.endPoint = segment.endPoint;
this.pathSegments.push(segment);
this.totalLength += segment.totalLength;
}
};
this.M = function (x, y) {
this.addCommand(['move', true, true, x, y]);
lastCom = 'M';
return this;
};
this.m = function (x, y) {
return this.M(currX + x, currY + y);
};
this.Z = this.z = function () {
this.addCommand(['close', true, true]);
lastCom = 'Z';
return this;
};
this.L = function (x, y) {
this.addCommand(['line', true, true, x, y]);
lastCom = 'L';
return this;
};
this.l = function (x, y) {
return this.L(currX + x, currY + y);
};
this.H = function (x) {
return this.L(x, currY);
};
this.h = function (x) {
return this.L(currX + x, currY);
};
this.V = function (y) {
return this.L(currX, y);
};
this.v = function (y) {
return this.L(currX, currY + y);
};
this.C = function (c1x, c1y, c2x, c2y, x, y) {
this.addCommand(['curve', true, true, c1x, c1y, c2x, c2y, x, y]);
lastCom = 'C';
lastCtrlX = c2x;
lastCtrlY = c2y;
return this;
};
this.c = function (c1x, c1y, c2x, c2y, x, y) {
return this.C(currX + c1x, currY + c1y, currX + c2x, currY + c2y, currX + x, currY + y);
};
this.S = function (c1x, c1y, x, y) {
return this.C(currX + (lastCom === 'C' ? currX - lastCtrlX : 0), currY + (lastCom === 'C' ? currY - lastCtrlY : 0), c1x, c1y, x, y);
};
this.s = function (c1x, c1y, x, y) {
return this.C(currX + (lastCom === 'C' ? currX - lastCtrlX : 0), currY + (lastCom === 'C' ? currY - lastCtrlY : 0), currX + c1x, currY + c1y, currX + x, currY + y);
};
this.Q = function (cx, cy, x, y) {
let c1x = currX + 2 / 3 * (cx - currX),
c1y = currY + 2 / 3 * (cy - currY),
c2x = x + 2 / 3 * (cx - x),
c2y = y + 2 / 3 * (cy - y);
this.addCommand(['curve', true, true, c1x, c1y, c2x, c2y, x, y]);
lastCom = 'Q';
lastCtrlX = cx;
lastCtrlY = cy;
return this;
};
this.q = function (c1x, c1y, x, y) {
return this.Q(currX + c1x, currY + c1y, currX + x, currY + y);
};
this.T = function (x, y) {
return this.Q(currX + (lastCom === 'Q' ? currX - lastCtrlX : 0), currY + (lastCom === 'Q' ? currY - lastCtrlY : 0), x, y);
};
this.t = function (x, y) {
return this.Q(currX + (lastCom === 'Q' ? currX - lastCtrlX : 0), currY + (lastCom === 'Q' ? currY - lastCtrlY : 0), currX + x, currY + y);
};
this.A = function (rx, ry, fi, fa, fs, x, y) {
if (isEqual(rx, 0) || isEqual(ry, 0)) {
this.addCommand(['line', true, true, x, y]);
} else {
fi = fi * (Math.PI / 180);
rx = Math.abs(rx);
ry = Math.abs(ry);
fa = 1 * !!fa;
fs = 1 * !!fs;
let x1 = Math.cos(fi) * (currX - x) / 2 + Math.sin(fi) * (currY - y) / 2,
y1 = Math.cos(fi) * (currY - y) / 2 - Math.sin(fi) * (currX - x) / 2,
lambda = x1 * x1 / (rx * rx) + y1 * y1 / (ry * ry);
if (lambda > 1) {
rx *= Math.sqrt(lambda);
ry *= Math.sqrt(lambda);
}
let r = Math.sqrt(Math.max(0, rx * rx * ry * ry - rx * rx * y1 * y1 - ry * ry * x1 * x1) / (rx * rx * y1 * y1 + ry * ry * x1 * x1)),
x2 = (fa === fs ? -1 : 1) * r * rx * y1 / ry,
y2 = (fa === fs ? 1 : -1) * r * ry * x1 / rx;
let cx = Math.cos(fi) * x2 - Math.sin(fi) * y2 + (currX + x) / 2,
cy = Math.sin(fi) * x2 + Math.cos(fi) * y2 + (currY + y) / 2,
th1 = Math.atan2((y1 - y2) / ry, (x1 - x2) / rx),
th2 = Math.atan2((-y1 - y2) / ry, (-x1 - x2) / rx);
if (fs === 0 && th2 - th1 > 0) {
th2 -= 2 * Math.PI;
} else if (fs === 1 && th2 - th1 < 0) {
th2 += 2 * Math.PI;
}
let segms = Math.ceil(Math.abs(th2 - th1) / (Math.PI / precision));
for (let i = 0; i < segms; i++) {
let th3 = th1 + i * (th2 - th1) / segms,
th4 = th1 + (i + 1) * (th2 - th1) / segms,
t = 4 / 3 * Math.tan((th4 - th3) / 4);
let c1x = cx + Math.cos(fi) * rx * (Math.cos(th3) - t * Math.sin(th3)) - Math.sin(fi) * ry * (Math.sin(th3) + t * Math.cos(th3)),
c1y = cy + Math.sin(fi) * rx * (Math.cos(th3) - t * Math.sin(th3)) + Math.cos(fi) * ry * (Math.sin(th3) + t * Math.cos(th3)),
c2x = cx + Math.cos(fi) * rx * (Math.cos(th4) + t * Math.sin(th4)) - Math.sin(fi) * ry * (Math.sin(th4) - t * Math.cos(th4)),
c2y = cy + Math.sin(fi) * rx * (Math.cos(th4) + t * Math.sin(th4)) + Math.cos(fi) * ry * (Math.sin(th4) - t * Math.cos(th4)),
endX = cx + Math.cos(fi) * rx * Math.cos(th4) - Math.sin(fi) * ry * Math.sin(th4),
endY = cy + Math.sin(fi) * rx * Math.cos(th4) + Math.cos(fi) * ry * Math.sin(th4);
this.addCommand(['curve', i === 0, i === segms - 1, c1x, c1y, c2x, c2y, endX, endY]);
}
}
lastCom = 'A';
return this;
};
this.a = function (rx, ry, fi, fa, fs, x, y) {
return this.A(rx, ry, fi, fa, fs, currX + x, currY + y);
};
this.path = function (d) {
let command,
value,
temp,
parser = new StringParser((d || '').trim());
while (command = parser.match(/^[astvzqmhlcASTVZQMHLC]/)) {
parser.matchSeparator();
let values = [];
while (value = PathFlags[command + values.length] ? parser.match(/^[01]/) : parser.matchNumber()) {
parser.matchSeparator();
if (values.length === PathArguments[command]) {
this[command].apply(this, values);
values = [];
if (command === 'M') {
command = 'L';
} else if (command === 'm') {
command = 'l';
}
}
values.push(Number(value));
}
if (values.length === PathArguments[command]) {
this[command].apply(this, values);
} else {
warningCallback('SvgPath: command ' + command + ' with ' + values.length + ' numbers');
return;
}
}
if (temp = parser.matchAll()) {
warningCallback('SvgPath: unexpected string ' + temp);
}
return this;
};
this.getBoundingBox = function () {
let bbox = [Infinity, Infinity, -Infinity, -Infinity];
function addBounds(bbox1) {
if (bbox1[0] < bbox[0]) {
bbox[0] = bbox1[0];
}
if (bbox1[2] > bbox[2]) {
bbox[2] = bbox1[2];
}
if (bbox1[1] < bbox[1]) {
bbox[1] = bbox1[1];
}
if (bbox1[3] > bbox[3]) {
bbox[3] = bbox1[3];
}
}
for (let i = 0; i < this.pathSegments.length; i++) {
addBounds(this.pathSegments[i].getBoundingBox());
}
if (bbox[0] === Infinity) {
bbox[0] = 0;
}
if (bbox[1] === Infinity) {
bbox[1] = 0;
}
if (bbox[2] === -Infinity) {
bbox[2] = 0;
}
if (bbox[3] === -Infinity) {
bbox[3] = 0;
}
return bbox;
};
this.getPointAtLength = function (l) {
if (l >= 0 && l <= this.totalLength) {
let temp;
for (let i = 0; i < this.pathSegments.length; i++) {
if (temp = this.pathSegments[i].getPointAtLength(l)) {
return temp;
}
l -= this.pathSegments[i].totalLength;
}
return this.endPoint;
}
};
this.transform = function (m) {
this.pathSegments = [];
this.startPoint = null;
this.endPoint = null;
this.totalLength = 0;
for (let i = 0; i < this.pathCommands.length; i++) {
let data = this.pathCommands.shift();
for (let j = 3; j < data.length; j += 2) {
let p = transformPoint([data[j], data[j + 1]], m);
data[j] = p[0];
data[j + 1] = p[1];
}
this.addCommand(data);
}
return this;
};
this.mergeShape = function (shape) {
for (let i = 0; i < shape.pathCommands.length; i++) {
this.addCommand(shape.pathCommands[i].slice());
}
return this;
};
this.clone = function () {
return new SvgShape().mergeShape(this);
};
this.insertInDocument = function () {
for (let i = 0; i < this.pathCommands.length; i++) {
let command = this.pathCommands[i][0],
values = this.pathCommands[i].slice(3);
switch (command) {
case 'move':
doc.moveTo(values[0], values[1]);
break;
case 'line':
doc.lineTo(values[0], values[1]);
break;
case 'curve':
doc.bezierCurveTo(values[0], values[1], values[2], values[3], values[4], values[5]);
break;
case 'close':
doc.closePath();
break;
}
}
};
this.getSubPaths = function () {
let subPaths = [],
shape = new SvgShape();
for (let i = 0; i < this.pathCommands.length; i++) {
let data = this.pathCommands[i],
command = this.pathCommands[i][0];
if (command === 'move' && i !== 0) {
subPaths.push(shape);
shape = new SvgShape();
}
shape.addCommand(data);
}
subPaths.push(shape);
return subPaths;
};
this.getMarkers = function () {
let markers = [],
subPaths = this.getSubPaths();
for (let i = 0; i < subPaths.length; i++) {
let subPath = subPaths[i],
subPathMarkers = [];
for (let j = 0; j < subPath.pathSegments.length; j++) {
let segment = subPath.pathSegments[j];
if (isNotEqual(segment.totalLength, 0) || j === 0 || j === subPath.pathSegments.length - 1) {
if (segment.hasStart) {
let startMarker = segment.getPointAtLength(0),
prevEndMarker = subPathMarkers.pop();
if (prevEndMarker) {
startMarker[2] = 0.5 * (prevEndMarker[2] + startMarker[2]);
}
subPathMarkers.push(startMarker);
}
if (segment.hasEnd) {
let endMarker = segment.getPointAtLength(segment.totalLength);
subPathMarkers.push(endMarker);
}
}
}
markers = markers.concat(subPathMarkers);
}
return markers;
};
};
var SvgElem = function (obj, inherits) {
// Bound both the size and depth of trees expanded through <use> references.
this.useDepth = inherits ? inherits.useDepth + (inherits instanceof SvgElemUse ? 1 : 0) : 0;
if (this.useDepth > MAX_USE_DEPTH) {
throw new Error('SVGtoPDF: <use> reference depth limit exceeded (' + MAX_USE_DEPTH + ')');
}
if (this.useDepth && ++useExpansionElements > MAX_USE_EXPANSION_ELEMENTS) {
throw new Error('SVGtoPDF: <use> expansion limit exceeded (' + MAX_USE_EXPANSION_ELEMENTS + ' elements)');
}
let styleCache = Object.create(null);
let childrenCache = null;
this.name = obj.nodeName;
this.isOuterElement = obj === svg || !obj.parentNode;
this.inherits = inherits || (!this.isOuterElement ? createSVGElement(obj.parentNode, null) : null);
this.stack = this.inherits ? this.inherits.stack.concat(obj) : [obj];
this.style = parseStyleAttr(typeof obj.getAttribute === 'function' && obj.getAttribute('style'));
this.css = useCSS ? getComputedStyle(obj) : getStyle(obj);
this.allowedChildren = [];
this.attr = function (key) {
if (typeof obj.getAttribute === 'function') {
return obj.getAttribute(key);
}
};
this.resolveUrl = function (value) {
let temp = (value || '').match(/^\s*(?:url\("(.*)#(.*)"\)|url\('(.*)#(.*)'\)|url\((.*)#(.*)\)|(.*)#(.*))\s*$/) || [];
let file = temp[1] || temp[3] || temp[5] || temp[7],
id = temp[2] || temp[4] || temp[6] || temp[8];
if (id) {
if (!file) {
let svgObj = svg.getElementById(id);
if (svgObj) {
if (this.stack.indexOf(svgObj) === -1) {
return svgObj;
} else {
warningCallback('SVGtoPDF: loop of circular references for id "' + id + '"');
return;
}
}
}
if (documentCallback) {
let svgs = documentCache[file];
if (!svgs) {
svgs = documentCallback(file);
if (!isArrayLike(svgs)) {
svgs = [svgs];
}
for (let i = 0; i < svgs.length; i++) {
if (typeof svgs[i] === 'string') {
svgs[i] = parseXml(svgs[i]);
}
}
documentCache[file] = svgs;
}
for (let i = 0; i < svgs.length; i++) {
let svgObj = svgs[i].getElementById(id);
if (svgObj) {
if (this.stack.indexOf(svgObj) === -1) {
return svgObj;
} else {
warningCallback('SVGtoPDF: loop of circular references for id "' + file + '#' + id + '"');
return;
}
}
}
}
}
};
this.computeUnits = function (value, unit, percent, isFontSize) {
if (unit === '%') {
return parseFloat(value) / 100 * (isFontSize || percent != null ? percent : this.getViewport());
} else if (unit === 'ex' || unit === 'em') {
return value * {
'em': 1,
'ex': 0.5
}[unit] * (isFontSize ? percent : this.get('font-size'));
} else {
return value * {
'': 1,
'px': 1,
'pt': 96 / 72,
'cm': 96 / 2.54,
'mm': 96 / 25.4,
'in': 96,
'pc': 96 / 6
}[unit];
}
};
this.computeLength = function (value, percent, initial, isFontSize) {
let parser = new StringParser((value || '').trim()),
temp1,
temp2;
if (typeof (temp1 = parser.matchNumber()) === 'string' && typeof (temp2 = parser.matchLengthUnit()) === 'string' && !parser.matchAll()) {
return this.computeUnits(temp1, temp2, percent, isFontSize);
}
return initial;
};
this.computeLengthList = function (value, percent, strict) {
let parser = new StringParser((value || '').trim()),
result = [],
temp1,
temp2;
while (typeof (temp1 = parser.matchNumber()) === 'string' && typeof (temp2 = parser.matchLengthUnit()) === 'string') {
result.push(this.computeUnits(temp1, temp2, percent));
parser.matchSeparator();
}
if (strict && parser.matchAll()) {
return;
}
return result;
};
this.getLength = function (key, percent, initial) {
return this.computeLength(this.attr(key), percent, initial);
};
this.getLengthList = function (key, percent) {
return this.computeLengthList(this.attr(key), percent);
};
this.getUrl = function (key) {
return this.resolveUrl(this.attr(key));
};
this.getNumberList = function (key) {
let parser = new StringParser((this.attr(key) || '').trim()),
result = [],
temp;
while (temp = parser.matchNumber()) {
result.push(Number(temp));
parser.matchSeparator();
}
result.error = parser.matchAll();
return result;
};
this.getViewbox = function (key, initial) {
let viewBox = this.getNumberList(key);
if (viewBox.length === 4 && viewBox[2] >= 0 && viewBox[3] >= 0) {
return viewBox;
}
return initial;
};
this.getPercent = function (key, initial) {
let value = this.attr(key);
let parser = new StringParser((value || '').trim()),
temp1,
temp2;
let number = parser.matchNumber();
if (!number) {
return initial;
}
if (parser.match('%')) {
number *= 0.01;
}
if (parser.matchAll()) {
return initial;
}
return Math.max(0, Math.min(1, number));
};
this.chooseValue = function (args) {
for (let i = 0; i < arguments.length; i++) {
if (arguments[i] != null && arguments[i] === arguments[i]) {
return arguments[i];
}
}
return arguments[arguments.length - 1];
};
this.get = function (key) {
if (styleCache[key] !== undefined) {
return styleCache[key];
}
let keyInfo = Properties[key] || {},
value,
result;
for (let i = 0; i < 3; i++) {
switch (i) {
case 0:
if (key !== 'transform') {
// the CSS transform behaves strangely
value = this.css[keyInfo.css || key];
}
break;
case 1:
value = this.style[key];
break;
case 2:
value = this.attr(key);
break;
}
if (value === 'inherit') {
result = this.inherits ? this.inherits.get(key) : keyInfo.initial;
if (result != null) {
return styleCache[key] = result;
}
}
if (keyInfo.values != null) {
result = keyInfo.values[value];
if (result != null) {
return styleCache[key] = result;
}
}
if (value != null) {
let parsed;
switch (key) {
case 'font-size':
result = this.computeLength(value, this.inherits ? this.inherits.get(key) : keyInfo.initial, undefined, true);
break;
case 'baseline-shift':
result = this.computeLength(value, this.get('font-size'));
break;
case 'font-family':
result = value || undefined;
break;
case 'opacity':
case 'stroke-opacity':
case 'fill-opacity':
case 'stop-opacity':
parsed = parseFloat(value);
if (!isNaN(parsed)) {
result = Math.max(0, Math.min(1, parsed));
}
break;
case 'transform':
result = parseTranform(value);
break;
case 'stroke-dasharray':
if (value === 'none') {
result = [];
} else if (parsed = this.computeLengthList(value, this.getViewport(), true)) {
let sum = 0,
error = false;
for (let j = 0; j < parsed.length; j++) {
if (parsed[j] < 0) {
error = true;
}
sum += parsed[j];
}
if (!error) {
if (parsed.length % 2 === 1) {
parsed = parsed.concat(parsed);
}
result = sum === 0 ? [] : parsed;
}
}
break;
case 'color':
if (value === 'none' || value === 'transparent') {
result = 'none';
} else {
result = parseColor(value);
}
break;
case 'fill':
case 'stroke':
if (value === 'none' || value === 'transparent') {
result = 'none';
} else if (value === 'currentColor') {
result = this.get('color');
} else if (parsed = parseColor(value)) {
return parsed;
} else if (parsed = (value || '').split(' ')) {
let object = this.resolveUrl(parsed[0]),
fallbackColor = parseColor(parsed[1]);
if (object == null) {
result = fallbackColor;
} else if (object.nodeName === 'linearGradient' || object.nodeName === 'radialGradient') {
result = new SvgElemGradient(object, null, fallbackColor);
} else if (object.nodeName === 'pattern') {
result = new SvgElemPattern(object, null, fallbackColor);
} else {
result = fallbackColor;
}
}
break;
case 'stop-color':
if (value === 'none' || value === 'transparent') {
result = 'none';
} else if (value === 'currentColor') {
result = this.get('color');
} else {
result = parseColor(value);
}
break;
case 'marker-start':
case 'marker-mid':
case 'marker-end':
case 'clip-path':
case 'mask':
if (value === 'none') {
result = 'none';
} else {
result = this.resolveUrl(value);
}
break;
case 'stroke-width':
parsed = this.computeLength(value, this.getViewport());
if (parsed != null && parsed >= 0) {
result = parsed;
}
break;
case 'stroke-miterlimit':
parsed = parseFloat(value);
if (parsed != null && parsed >= 1) {
result = parsed;
}
break;
case 'word-spacing':
case 'letter-spacing':
result = this.computeLength(value, this.getViewport());
break;
case 'stroke-dashoffset':
result = this.computeLength(value, this.getViewport());
break;
}
if (result != null) {
return styleCache[key] = result;
}
}
}
return styleCache[key] = keyInfo.inherit && this.inherits ? this.inherits.get(key) : keyInfo.initial;
};
this.getChildren = function () {
if (childrenCache != null) {
return childrenCache;
}
let children = [];
for (let i = 0; i < obj.childNodes.length; i++) {
let child = obj.childNodes[i];
if (!child.error && this.allowedChildren.indexOf(child.nodeName) !== -1) {
children.push(createSVGElement(child, this));
}
}
return childrenCache = children;
};
this.getParentVWidth = function () {
return this.inherits ? this.inherits.getVWidth() : viewportWidth;
};
this.getParentVHeight = function () {
return this.inherits ? this.inherits.getVHeight() : viewportHeight;
};
this.getParentViewport = function () {
return Math.sqrt(0.5 * this.getParentVWidth() * this.getParentVWidth() + 0.5 * this.getParentVHeight() * this.getParentVHeight());
};
this.getVWidth = function () {
return this.getParentVWidth();
};
this.getVHeight = function () {
return this.getParentVHeight();
};
this.getViewport = function () {
return Math.sqrt(0.5 * this.getVWidth() * this.getVWidth() + 0.5 * this.getVHeight() * this.getVHeight());
};
this.getBoundingBox = function () {
let shape = this.getBoundingShape();
return shape.getBoundingBox();
};
};
var SvgElemStylable = function (obj, inherits) {
SvgElem.call(this, obj, inherits);
this.transform = function () {
doc.transform.apply(doc, this.getTransformation());
};
this.clip = function () {
if (this.get('clip-path') !== 'none') {
let clipPath = new SvgElemClipPath(this.get('clip-path'), null);
clipPath.useMask(clipPath.attr('clipPathUnits') === 'objectBoundingBox' ? this.getBoundingBox() : null);
return true;
}
};
this.mask = function () {
if (this.get('mask') !== 'none') {
let mask = new SvgElemMask(this.get('mask'), null);
mask.useMask(this.getBoundingBox());
return true;
}
};
this.getFill = function (isClip, isMask) {
let opacity = this.get('opacity'),
fill = this.get('fill'),
fillOpacity = this.get('fill-opacity');
if (isClip) {
return DefaultColors.white;
}
if (fill !== 'none' && opacity && fillOpacity) {
if (fill instanceof SvgElemGradient || fill instanceof SvgElemPattern) {
return fill.getPaint(this.getBoundingBox(), fillOpacity * opacity, isClip, isMask);
}
return opacityToColor(fill, fillOpacity * opacity, isMask);
}
};
this.getStroke = function (isClip, isMask) {
let opacity = this.get('opacity'),
stroke = this.get('stroke'),
strokeOpacity = this.get('stroke-opacity');
if (isClip || isEqual(this.get('stroke-width'), 0)) {
return;
}
if (stroke !== 'none' && opacity && strokeOpacity) {
if (stroke instanceof SvgElemGradient || stroke instanceof SvgElemPattern) {
return stroke.getPaint(this.getBoundingBox(), strokeOpacity * opacity, isClip, isMask);
}
return opacityToColor(stroke, strokeOpacity * opacity, isMask);
}
};
};
var SvgElemHasChildren = function (obj, inherits) {
SvgElemStylable.call(this, obj, inherits);
this.allowedChildren = ['use', 'g', 'a', 'svg', 'image', 'rect', 'circle', 'ellipse', 'line', 'polyline', 'polygon', 'path', 'text'];
this.getBoundingShape = function () {
let shape = new SvgShape(),
children = this.getChildren();
for (let i = 0; i < children.length; i++) {
if (children[i].get('display') !== 'none') {
if (typeof children[i].getBoundingShape === 'function') {
let childShape = children[i].getBoundingShape().clone();
if (typeof children[i].getTransformation === 'function') {
childShape.transform(children[i].getTransformation());
}
shape.mergeShape(childShape);
}
}
}
return shape;
};
this.drawChildren = function (isClip, isMask) {
let children = this.getChildren();
for (let i = 0; i < children.length; i++) {
if (children[i].get('display') !== 'none') {
if (typeof children[i].drawInDocument === 'function') {
children[i].drawInDocument(isClip, isMask);
}
}
}
};
};
var SvgElemContainer = function (obj, inherits) {
SvgElemHasChildren.call(this, obj, inherits);
this.drawContent = function (isClip, isMask) {
this.transform();
let clipped = this.clip(),
masked = this.mask(),
group;
if ((this.get('opacity') < 1 || clipped || masked) && !isClip) {
group = docBeginGroup(getPageBBox());
}
this.drawChildren(isClip, isMask);
if (group) {
docEndGroup(group);
doc.fillOpacity(this.get('opacity'));
docInsertGroup(group);
}
};
};
var SvgElemUse = function (obj, inherits) {
SvgElemContainer.call(this, obj, inherits);
let x = this.getLength('x', this.getVWidth(), 0),
y = this.getLength('y', this.getVHeight(), 0),
child = this.getUrl('href') || this.getUrl('xlink:href');
if (child) {
child = createSVGElement(child, this);
}
this.getChildren = function () {
return child ? [child] : [];
};
this.drawInDocument = function (isClip, isMask) {
doc.save();
this.drawContent(isClip, isMask);
doc.restore();
};
this.getTransformation = function () {
return multiplyMatrix(this.get('transform'), [1, 0, 0, 1, x, y]);
};
};
var SvgElemSymbol = function (obj, inherits) {
SvgElemContainer.call(this, obj, inherits);
let width = this.getLength('width', this.getParentVWidth(), this.getParentVWidth()),
height = this.getLength('height', this.getParentVHeight(), this.getParentVHeight());
if (inherits instanceof SvgElemUse) {
width = inherits.getLength('width', inherits.getParentVWidth(), width);
height = inherits.getLength('height', inherits.getParentVHeight(), height);
}
let aspectRatio = (this.attr('preserveAspectRatio') || '').trim(),
viewBox = this.getViewbox('viewBox', [0, 0, width, height]);
this.getVWidth = function () {
return viewBox[2];
};
this.getVHeight = function () {
return viewBox[3];
};
this.drawInDocument = function (isClip, isMask) {
doc.save();
this.drawContent(isClip, isMask);
doc.restore();
};
this.getTransformation = function () {
return multiplyMatrix(parseAspectRatio(aspectRatio, width, height, viewBox[2], viewBox[3]), [1, 0, 0, 1, -viewBox[0], -viewBox[1]]);
};
};
var SvgElemGroup = function (obj, inherits) {
SvgElemContainer.call(this, obj, inherits);
this.drawInDocument = function (isClip, isMask) {
doc.save();
if (this.link && !isClip && !isMask) {
this.addLink();
}
this.drawContent(isClip, isMask);
doc.restore();
};
this.getTransformation = function () {
return this.get('transform');
};
};
var SvgElemLink = function (obj, inherits) {
if (inherits && inherits.isText) {
SvgElemTspan.call(this, obj, inherits);
this.allowedChildren = ['textPath', 'tspan', '#text', '#cdata-section', 'a'];
} else {
SvgElemGroup.call(this, obj, inherits);
}
this.link = this.attr('href') || this.attr('xlink:href');
this.addLink = function () {
if (this.link.match(/^(?:[a-z][a-z0-9+.-]*:|\/\/)?/i) && this.getChildren().length) {
let bbox = this.getBoundingShape().transform(getGlobalMatrix()).getBoundingBox();
docInsertLink(bbox[0], bbox[1], bbox[2], bbox[3], this.link);
}
};
};
var SvgElemSvg = function (obj, inherits) {
SvgElemContainer.call(this, obj, inherits);
let width = this.getLength('width', this.getParentVWidth(), this.getParentVWidth()),
height = this.getLength('height', this.getParentVHeight(), this.getParentVHeight()),
x = this.getLength('x', this.getParentVWidth(), 0),
y = this.getLength('y', this.getParentVHeight(), 0);
if (inherits instanceof SvgElemUse) {
width = inherits.getLength('width', inherits.getParentVWidth(), width);
height = inherits.getLength('height', inherits.getParentVHeight(), height);
}
let aspectRatio = this.attr('preserveAspectRatio'),
viewBox = this.getViewbox('viewBox', [0, 0, width, height]);
if (this.isOuterElement && preserveAspectRatio) {
x = y = 0;
width = viewportWidth;
height = viewportHeight;
aspectRatio = preserveAspectRatio;
}
this.getVWidth = function () {
return viewBox[2];
};
this.getVHeight = function () {
return viewBox[3];
};
this.drawInDocument = function (isClip, isMask) {
doc.save();
if (this.get('overflow') === 'hidden') {
new SvgShape().M(x, y).L(x + width, y).L(x + width, y + height).L(x, y + height).Z().transform(this.get('transform')).insertInDocument();
doc.clip();
}
this.drawContent(isClip, isMask);
doc.restore();
};
this.getTransformation = function () {
return multiplyMatrix(this.get('transform'), [1, 0, 0, 1, x, y], parseAspectRatio(aspectRatio, width, height, viewBox[2], viewBox[3]), [1, 0, 0, 1, -viewBox[0], -viewBox[1]]);
};
};
var SVGElemImage = function (obj, inherits) {
SvgElemStylable.call(this, obj, inherits);
let link = imageCallback(this.attr('href') || this.attr('xlink:href') || ''),
x = this.getLength('x', this.getVWidth(), 0),
y = this.getLength('y', this.getVHeight(), 0),
width = this.getLength('width', this.getVWidth(), 'auto'),
height = this.getLength('height', this.getVHeight(), 'auto'),
image;
try {
image = doc.openImage(link);
} catch (e) {
warningCallback('SVGElemImage: failed to open image "' + link + '" in PDFKit');
}
if (image) {
if (width === 'auto' && height !== 'auto') {
width = height * image.width / image.height;
} else if (height === 'auto' && width !== 'auto') {
height = width * image.height / image.width;
} else if (width === 'auto' && height === 'auto') {
width = image.width;
height = image.height;
}
}
if (width === 'auto' || width < 0) {
width = 0;
}
if (height === 'auto' || height < 0) {
height = 0;
}
this.getTransformation = function () {
return this.get('transform');
};
this.getBoundingShape = function () {
return new SvgShape().M(x, y).L(x + width, y).M(x + width, y + height).L(x, y + height);
};
this.drawInDocument = function (isClip, isMask) {
if (this.get('visibility') === 'hidden' || !image) {
return;
}
doc.save();
this.transform();
if (this.get('overflow') === 'hidden') {
doc.rect(x, y, width, height).clip();
}
this.clip();
this.mask();
doc.translate(x, y);
doc.transform.apply(doc, parseAspectRatio(this.attr('preserveAspectRatio'), width, height, image ? image.width : width, image ? image.height : height));
if (!isClip) {
doc.fillOpacity(this.get('opacity'));
doc.image(image, 0, 0);
} else {
doc.rect(0, 0, image.width, image.height);
docFillColor(DefaultColors.white).fill();
}
doc.restore();
};
};
var SvgElemPattern = function (obj, inherits, fallback) {
SvgElemHasChildren.call(this, obj, inherits);
this.ref = function () {
let ref = this.getUrl('href') || this.getUrl('xlink:href');
if (ref && ref.nodeName === obj.nodeName) {
return new SvgElemPattern(ref, inherits, fallback);
}
}.call(this);
let _attr = this.attr;
this.attr = function (key) {
let attr = _attr.call(this, key);
if (attr != null || key === 'href' || key === 'xlink:href') {
return attr;
}
return this.ref ? this.ref.attr(key) : null;
};
let _getChildren = this.getChildren;
this.getChildren = function () {
let children = _getChildren.call(this);
if (children.length > 0) {
return children;
}
return this.ref ? this.ref.getChildren() : [];
};
this.getPaint = function (bBox, gOpacity, isClip, isMask) {
let bBoxUnitsPattern = this.attr('patternUnits') !== 'userSpaceOnUse',
bBoxUnitsContent = this.attr('patternContentUnits') === 'objectBoundingBox',
x = this.getLength('x', bBoxUnitsPattern ? 1 : this.getParentVWidth(), 0),
y = this.getLength('y', bBoxUnitsPattern ? 1 : this.getParentVHeight(), 0),
width = this.getLength('width', bBoxUnitsPattern ? 1 : this.getParentVWidth(), 0),
height = this.getLength('height', bBoxUnitsPattern ? 1 : this.getParentVHeight(), 0);
if (bBoxUnitsContent && !bBoxUnitsPattern) {
// Use the same units for pattern & pattern content
x = (x - bBox[0]) / (bBox[2] - bBox[0]) || 0;
y = (y - bBox[1]) / (bBox[3] - bBox[1]) || 0;
width = width / (bBox[2] - bBox[0]) || 0;
height = height / (bBox[3] - bBox[1]) || 0;
} else if (!bBoxUnitsContent && bBoxUnitsPattern) {
x = bBox[0] + x * (bBox[2] - bBox[0]);
y = bBox[1] + y * (bBox[3] - bBox[1]);
width = width * (bBox[2] - bBox[0]);
height = height * (bBox[3] - bBox[1]);
}
let viewBox = this.getViewbox('viewBox', [0, 0, width, height]),
aspectRatio = (this.attr('preserveAspectRatio') || '').trim(),
aspectRatioMatrix = multiplyMatrix(parseAspectRatio(aspectRatio, width, height, viewBox[2], viewBox[3], 0), [1, 0, 0, 1, -viewBox[0], -viewBox[1]]),
matrix = parseTranform(this.attr('patternTransform'));
if (bBoxUnitsContent) {
matrix = multiplyMatrix([bBox[2] - bBox[0], 0, 0, bBox[3] - bBox[1], bBox[0], bBox[1]], matrix);
}
matrix = multiplyMatrix(matrix, [1, 0, 0, 1, x, y]);
if ((matrix = validateMatrix(matrix)) && (aspectRatioMatrix = validateMatrix(aspectRatioMatrix)) && (width = validateNumber(width)) && (height = validateNumber(height))) {
let group = docBeginGroup([0, 0, width, height]);
doc.transform.apply(doc, aspectRatioMatrix);
this.drawChildren(isClip, isMask);
docEndGroup(group);
return [docCreatePattern(group, width, height, matrix), gOpacity];
} else {
return fallback ? [fallback[0], fallback[1] * gOpacity] : undefined;
}
};
this.getVWidth = function () {
let bBoxUnitsPattern = this.attr('patternUnits') !== 'userSpaceOnUse',
width = this.getLength('width', bBoxUnitsPattern ? 1 : this.getParentVWidth(), 0);
return this.getViewbox('viewBox', [0, 0, width, 0])[2];
};
this.getVHeight = function () {
let bBoxUnitsPattern = this.attr('patternUnits') !== 'userSpaceOnUse',
height = this.getLength('height', bBoxUnitsPattern ? 1 : this.getParentVHeight(), 0);
return this.getViewbox('viewBox', [0, 0, 0, height])[3];
};
};
var SvgElemGradient = function (obj, inherits, fallback) {
SvgElem.call(this, obj, inherits);
this.allowedChildren = ['stop'];
this.ref = function () {
let ref = this.getUrl('href') || this.getUrl('xlink:href');
if (ref && ref.nodeName === obj.nodeName) {
return new SvgElemGradient(ref, inherits, fallback);
}
}.call(this);
let _attr = this.attr;
this.attr = function (key) {
let attr = _attr.call(this, key);
if (attr != null || key === 'href' || key === 'xlink:href') {
return attr;
}
return this.ref ? this.ref.attr(key) : null;
};
let _getChildren = this.getChildren;
this.getChildren = function () {
let children = _getChildren.call(this);
if (children.length > 0) {
return children;
}
return this.ref ? this.ref.getChildren() : [];
};
this.getPaint = function (bBox, gOpacity, isClip, isMask) {
let children = this.getChildren();
if (children.length === 0) {
return;
}
if (children.length === 1) {
let child = children[0],
stopColor = child.get('stop-color');
if (stopColor === 'none') {
return;
}
return opacityToColor(stopColor, child.get('stop-opacity') * gOpacity, isMask);
}
let bBoxUnits = this.attr('gradientUnits') !== 'userSpaceOnUse',
matrix = parseTranform(this.attr('gradientTransform')),
spread = this.attr('spreadMethod'),
grad,
x1,
x2,
y1,
y2,
r2,
nAfter = 0,
nBefore = 0,
nTotal = 1;
if (bBoxUnits) {
matrix = multiplyMatrix([bBox[2] - bBox[0], 0, 0, bBox[3] - bBox[1], bBox[0], bBox[1]], matrix);
}
if (matrix = validateMatrix(matrix)) {
if (this.name === 'linearGradient') {
x1 = this.getLength('x1', bBoxUnits ? 1 : this.getVWidth(), 0);
x2 = this.getLength('x2', bBoxUnits ? 1 : this.getVWidth(), bBoxUnits ? 1 : this.getVWidth());
y1 = this.getLength('y1', bBoxUnits ? 1 : this.getVHeight(), 0);
y2 = this.getLength('y2', bBoxUnits ? 1 : this.getVHeight(), 0);
} else {
x2 = this.getLength('cx', bBoxUnits ? 1 : this.getVWidth(), bBoxUnits ? 0.5 : 0.5 * this.getVWidth());
y2 = this.getLength('cy', bBoxUnits ? 1 : this.getVHeight(), bBoxUnits ? 0.5 : 0.5 * this.getVHeight());
r2 = this.getLength('r', bBoxUnits ? 1 : this.getViewport(), bBoxUnits ? 0.5 : 0.5 * this.getViewport());
x1 = this.getLength('fx', bBoxUnits ? 1 : this.getVWidth(), x2);
y1 = this.getLength('fy', bBoxUnits ? 1 : this.getVHeight(), y2);
if (r2 < 0) {
warningCallback('SvgElemGradient: negative r value');
}
let d = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2)),
multiplier = 1;
if (d > r2) {
// according to specification
multiplier = r2 / d;
x1 = x2 + (x1 - x2) * multiplier;
y1 = y2 + (y1 - y2) * multiplier;
}
r2 = Math.max(r2, d * multiplier * (1 + 1e-6)); // fix for edge-case gradients see issue #84
}
if (spread === 'reflect' || spread === 'repeat') {
let inv = inverseMatrix(matrix),
corner1 = transformPoint([bBox[0], bBox[1]], inv),
corner2 = transformPoint([bBox[2], bBox[1]], inv),
corner3 = transformPoint([bBox[2], bBox[3]], inv),
corner4 = transformPoint([bBox[0], bBox[3]], inv);
if (this.name === 'linearGradient') {
// See file 'gradient-repeat-maths.png'
nAfter = Math.max((corner1[0] - x2) * (x2 - x1) + (corner1[1] - y2) * (y2 - y1), (corner2[0] - x2) * (x2 - x1) + (corner2[1] - y2) * (y2 - y1), (corner3[0] - x2) * (x2 - x1) + (corner3[1] - y2) * (y2 - y1), (corner4[0] - x2) * (x2 - x1) + (corner4[1] - y2) * (y2 - y1)) / (Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
nBefore = Math.max((corner1[0] - x1) * (x1 - x2) + (corner1[1] - y1) * (y1 - y2), (corner2[0] - x1) * (x1 - x2) + (corner2[1] - y1) * (y1 - y2), (corner3[0] - x1) * (x1 - x2) + (corner3[1] - y1) * (y1 - y2), (corner4[0] - x1) * (x1 - x2) + (corner4[1] - y1) * (y1 - y2)) / (Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
} else {
nAfter = Math.sqrt(Math.max(Math.pow(corner1[0] - x2, 2) + Math.pow(corner1[1] - y2, 2), Math.pow(corner2[0] - x2, 2) + Math.pow(corner2[1] - y2, 2), Math.pow(corner3[0] - x2, 2) + Math.pow(corner3[1] - y2, 2), Math.pow(corner4[0] - x2, 2) + Math.pow(corner4[1] - y2, 2))) / r2 - 1;
}
nAfter = Math.ceil(nAfter + 0.5); // Add a little more because the stroke can extend outside of the bounding box
nBefore = Math.ceil(nBefore + 0.5);
nTotal = nBefore + 1 + nAfter; // How many times the gradient needs to be repeated to fill the object bounding box
}
if (this.name === 'linearGradient') {
grad = doc.linearGradient(x1 - nBefore * (x2 - x1), y1 - nBefore * (y2 - y1), x2 + nAfter * (x2 - x1), y2 + nAfter * (y2 - y1));
} else {
grad = doc.radialGradient(x1, y1, 0, x2, y2, r2 + nAfter * r2);
}
for (let n = 0; n < nTotal; n++) {
let offset = 0,
inOrder = spread !== 'reflect' || (n - nBefore) % 2 === 0;
for (let i = 0; i < children.length; i++) {
let child = children[inOrder ? i : children.length - 1 - i],
stopColor = child.get('stop-color');
if (stopColor === 'none') {
stopColor = DefaultColors.transparent;
}
stopColor = opacityToColor(stopColor, child.get('stop-opacity') * gOpacity, isMask);
offset = Math.max(offset, inOrder ? child.getPercent('offset', 0) : 1 - child.getPercent('offset', 0));
if (i === 0 && stopColor[0].length === 4) {
grad._colorSpace = 'DeviceCMYK';
} // Fix until PR #763 is merged into PDFKit
if (i === 0 && offset > 0) {
grad.stop((n + 0) / nTotal, stopColor[0], stopColor[1]);
}
grad.stop((n + offset) / (nAfter + nBefore + 1), stopColor[0], stopColor[1]);
if (i === children.length - 1 && offset < 1) {
grad.stop((n + 1) / nTotal, stopColor[0], stopColor[1]);
}
}
}
grad.setTransform.apply(grad, matrix);
return [grad, 1];
} else {
return fallback ? [fallback[0], fallback[1] * gOpacity] : undefined;
}
};
};
var SvgElemBasicShape = function (obj, inherits) {
SvgElemStylable.call(this, obj, inherits);
this.dashScale = 1;
this.getBoundingShape = function () {
return this.shape;
};
this.getTransformation = function () {
return this.get('transform');
};
this.drawInDocument = function (isClip, isMask) {
if (this.get('visibility') === 'hidden' || !this.shape) {
return;
}
doc.save();
if (this.get('vector-effect') === 'non-scaling-stroke') {
this.shape.transform(this.getTransformation());
} else {
this.transform();
}
this.clip();
if (!isClip) {
let masked = this.mask(),
group;
if (masked) {
group = docBeginGroup(getPageBBox());
}
let subPaths = this.shape.getSubPaths(),
fill = this.getFill(isClip, isMask),
stroke = this.getStroke(isClip, isMask),
lineWidth = this.get('stroke-width'),
lineCap = this.get('stroke-linecap');
if (this.get('vector-effect') === 'non-scaling-stroke') {
lineWidth = lineWidth / getPageScale();
}
if (fill || stroke) {
if (fill) {
docFillColor(fill);
}
if (stroke) {
for (let j = 0; j < subPaths.length; j++) {
if (isEqual(subPaths[j].totalLength, 0)) {
if ((lineCap === 'square' || lineCap === 'round') && lineWidth > 0) {
if (subPaths[j].startPoint && subPaths[j].startPoint.length > 1) {
let x = subPaths[j].startPoint[0],
y = subPaths[j].startPoint[1];
docFillColor(stroke);
if (lineCap === 'square') {
doc.rect(x - 0.5 * lineWidth, y - 0.5 * lineWidth, lineWidth, lineWidth);
} else if (lineCap === 'round') {
doc.circle(x, y, 0.5 * lineWidth);
}
doc.fill();
}
}
}
}
let dashArray = this.get('stroke-dasharray'),
dashOffset = this.get('stroke-dashoffset');
if (isNotEqual(this.dashScale, 1)) {
for (let j = 0; j < dashArray.length; j++) {
dashArray[j] *= this.dashScale;
}
dashOffset *= this.dashScale;
}
docStrokeColor(stroke);
doc.lineWidth(lineWidth).miterLimit(this.get('stroke-miterlimit')).lineJoin(this.get('stroke-linejoin')).lineCap(lineCap);
docApplyDash(dashArray, dashOffset);
}
for (let j = 0; j < subPaths.length; j++) {
if (subPaths[j].totalLength > 0) {
subPaths[j].insertInDocument();
}
}
if (fill && stroke) {
doc.fillAndStroke(this.get('fill-rule'));
} else if (fill) {
doc.fill(this.get('fill-rule'));
} else if (stroke) {
doc.stroke();
}
}
let markerStart = this.get('marker-start'),
markerMid = this.get('marker-mid'),
markerEnd = this.get('marker-end');
if (markerStart !== 'none' || markerMid !== 'none' || markerEnd !== 'none') {
let markersPos = this.shape.getMarkers();
if (markerStart !== 'none' && markersPos.length > 0) {
let marker = new SvgElemMarker(markerStart, null);
marker.drawMarker(false, isMask, markersPos[0], lineWidth);
}
if (markerMid !== 'none') {
for (let i = 1; i < markersPos.length - 1; i++) {
let marker = new SvgElemMarker(markerMid, null);
marker.drawMarker(false, isMask, markersPos[i], lineWidth);
}
}
if (markerEnd !== 'none' && markersPos.length > 0) {
let marker = new SvgElemMarker(markerEnd, null);
marker.drawMarker(false, isMask, markersPos[markersPos.length - 1], lineWidth);
}
}
if (group) {
docEndGroup(group);
docInsertGroup(group);
}
} else {
this.shape.insertInDocument();
docFillColor(DefaultColors.white);
doc.fill(this.get('clip-rule'));
}
doc.restore();
};
};
var SvgElemRect = function (obj, inherits) {
SvgElemBasicShape.call(this, obj, inherits);
let x = this.getLength('x', this.getVWidth(), 0),
y = this.getLength('y', this.getVHeight(), 0),
w = this.getLength('width', this.getVWidth(), 0),
h = this.getLength('height', this.getVHeight(), 0),
rx = this.getLength('rx', this.getVWidth()),
ry = this.getLength('ry', this.getVHeight());
if (rx === undefined && ry === undefined) {
rx = ry = 0;
} else if (rx === undefined && ry !== undefined) {
rx = ry;
} else if (rx !== undefined && ry === undefined) {
ry = rx;
}
if (w > 0 && h > 0) {
if (rx && ry) {
rx = Math.min(rx, 0.5 * w);
ry = Math.min(ry, 0.5 * h);
this.shape = new SvgShape().M(x + rx, y).L(x + w - rx, y).A(rx, ry, 0, 0, 1, x + w, y + ry).L(x + w, y + h - ry).A(rx, ry, 0, 0, 1, x + w - rx, y + h).L(x + rx, y + h).A(rx, ry, 0, 0, 1, x, y + h - ry).L(x, y + ry).A(rx, ry, 0, 0, 1, x + rx, y).Z();
} else {
this.shape = new SvgShape().M(x, y).L(x + w, y).L(x + w, y + h).L(x, y + h).Z();
}
} else {
this.shape = new SvgShape();
}
};
var SvgElemCircle = function (obj, inherits) {
SvgElemBasicShape.call(this, obj, inherits);
let cx = this.getLength('cx', this.getVWidth(), 0),
cy = this.getLength('cy', this.getVHeight(), 0),
r = this.getLength('r', this.getViewport(), 0);
if (r > 0) {
this.shape = new SvgShape().M(cx + r, cy).A(r, r, 0, 0, 1, cx - r, cy).A(r, r, 0, 0, 1, cx + r, cy).Z();
} else {
this.shape = new SvgShape();
}
};
var SvgElemEllipse = function (obj, inherits) {
SvgElemBasicShape.call(this, obj, inherits);
let cx = this.getLength('cx', this.getVWidth(), 0),
cy = this.getLength('cy', this.getVHeight(), 0),
rx = this.getLength('rx', this.getVWidth(), 0),
ry = this.getLength('ry', this.getVHeight(), 0);
if (rx > 0 && ry > 0) {
this.shape = new SvgShape().M(cx + rx, cy).A(rx, ry, 0, 0, 1, cx - rx, cy).A(rx, ry, 0, 0, 1, cx + rx, cy).Z();
} else {
this.shape = new SvgShape();
}
};
var SvgElemLine = function (obj, inherits) {
SvgElemBasicShape.call(this, obj, inherits);
let x1 = this.getLength('x1', this.getVWidth(), 0),
y1 = this.getLength('y1', this.getVHeight(), 0),
x2 = this.getLength('x2', this.getVWidth(), 0),
y2 = this.getLength('y2', this.getVHeight(), 0);
this.shape = new SvgShape().M(x1, y1).L(x2, y2);
};
var SvgElemPolyline = function (obj, inherits) {
SvgElemBasicShape.call(this, obj, inherits);
let points = this.getNumberList('points');
this.shape = new SvgShape();
for (let i = 0; i < points.length - 1; i += 2) {
if (i === 0) {
this.shape.M(points[i], points[i + 1]);
} else {
this.shape.L(points[i], points[i + 1]);
}
}
if (points.error) {
warningCallback('SvgElemPolygon: unexpected string ' + points.error);
}
if (points.length % 2 === 1) {
warningCallback('SvgElemPolyline: uneven number of coordinates');
}
};
var SvgElemPolygon = function (obj, inherits) {
SvgElemBasicShape.call(this, obj, inherits);
let points = this.getNumberList('points');
this.shape = new SvgShape();
for (let i = 0; i < points.length - 1; i += 2) {
if (i === 0) {
this.shape.M(points[i], points[i + 1]);
} else {
this.shape.L(points[i], points[i + 1]);
}
}
this.shape.Z();
if (points.error) {
warningCallback('SvgElemPolygon: unexpected string ' + points.error);
}
if (points.length % 2 === 1) {
warningCallback('SvgElemPolygon: uneven number of coordinates');
}
};
var SvgElemPath = function (obj, inherits) {
SvgElemBasicShape.call(this, obj, inherits);
this.shape = new SvgShape().path(this.attr('d'));
let pathLength = this.getLength('pathLength', this.getViewport());
this.pathLength = pathLength > 0 ? pathLength : undefined;
this.dashScale = this.pathLength !== undefined ? this.shape.totalLength / this.pathLength : 1;
};
var SvgElemMarker = function (obj, inherits) {
SvgElemHasChildren.call(this, obj, inherits);
let width = this.getLength('markerWidth', this.getParentVWidth(), 3),
height = this.getLength('markerHeight', this.getParentVHeight(), 3),
viewBox = this.getViewbox('viewBox', [0, 0, width, height]);
this.getVWidth = function () {
return viewBox[2];
};
this.getVHeight = function () {
return viewBox[3];
};
this.drawMarker = function (isClip, isMask, posArray, strokeWidth) {
doc.save();
let orient = this.attr('orient'),
units = this.attr('markerUnits'),
rotate = orient === 'auto' ? posArray[2] : (parseFloat(orient) || 0) * Math.PI / 180,
scale = units === 'userSpaceOnUse' ? 1 : strokeWidth;
doc.transform(Math.cos(rotate) * scale, Math.sin(rotate) * scale, -Math.sin(rotate) * scale, Math.cos(rotate) * scale, posArray[0], posArray[1]);
let refX = this.getLength('refX', this.getVWidth(), 0),
refY = this.getLength('refY', this.getVHeight(), 0),
aspectRatioMatrix = parseAspectRatio(this.attr('preserveAspectRatio'), width, height, viewBox[2], viewBox[3], 0.5);
if (this.get('overflow') === 'hidden') {
doc.rect(aspectRatioMatrix[0] * (viewBox[0] + viewBox[2] / 2 - refX) - width / 2, aspectRatioMatrix[3] * (viewBox[1] + viewBox[3] / 2 - refY) - height / 2, width, height).clip();
}
doc.transform.apply(doc, aspectRatioMatrix);
doc.translate(-refX, -refY);
let group;
if (this.get('opacity') < 1 && !isClip) {
group = docBeginGroup(getPageBBox());
}
this.drawChildren(isClip, isMask);
if (group) {
docEndGroup(group);
doc.fillOpacity(this.get('opacity'));
docInsertGroup(group);
}
doc.restore();
};
};
var SvgElemClipPath = function (obj, inherits) {
SvgElemHasChildren.call(this, obj, inherits);
this.useMask = function (bBox) {
let group = docBeginGroup(getPageBBox());
doc.save();
doc.transform.apply(doc, this.get('transform'));
if (this.attr('clipPathUnits') === 'objectBoundingBox') {
doc.transform(bBox[2] - bBox[0], 0, 0, bBox[3] - bBox[1], bBox[0], bBox[1]);
}
this.clip();
this.drawChildren(true, false);
doc.restore();
docEndGroup(group);
docApplyMask(group, true);
};
};
var SvgElemMask = function (obj, inherits) {
SvgElemHasChildren.call(this, obj, inherits);
this.useMask = function (bBox) {
let group = docBeginGroup(getPageBBox());
doc.save();
let x, y, w, h;
if (this.attr('maskUnits') === 'userSpaceOnUse') {
x = this.getLength('x', this.getVWidth(), -0.1 * (bBox[2] - bBox[0]) + bBox[0]);
y = this.getLength('y', this.getVHeight(), -0.1 * (bBox[3] - bBox[1]) + bBox[1]);
w = this.getLength('width', this.getVWidth(), 1.2 * (bBox[2] - bBox[0]));
h = this.getLength('height', this.getVHeight(), 1.2 * (bBox[3] - bBox[1]));
} else {
x = this.getLength('x', this.getVWidth(), -0.1) * (bBox[2] - bBox[0]) + bBox[0];
y = this.getLength('y', this.getVHeight(), -0.1) * (bBox[3] - bBox[1]) + bBox[1];
w = this.getLength('width', this.getVWidth(), 1.2) * (bBox[2] - bBox[0]);
h = this.getLength('height', this.getVHeight(), 1.2) * (bBox[3] - bBox[1]);
}
if (this.attr('maskContentUnits') === 'objectBoundingBox') {
doc.transform(bBox[2] - bBox[0], 0, 0, bBox[3] - bBox[1], bBox[0], bBox[1]);
}
this.clip();
this.drawChildren(false, true);
doc.restore();
docEndGroup(group);
docApplyMask(group, true);
};
};
var SvgElemTextContainer = function (obj, inherits) {
SvgElemStylable.call(this, obj, inherits);
this.allowedChildren = ['tspan', '#text', '#cdata-section', 'a'];
this.isText = true;
this.getBoundingShape = function () {
let shape = new SvgShape();
for (let i = 0; i < this._pos.length; i++) {
let pos = this._pos[i];
if (!pos.hidden) {
let dx0 = pos.ascent * Math.sin(pos.rotate),
dy0 = -pos.ascent * Math.cos(pos.rotate),
dx1 = pos.descent * Math.sin(pos.rotate),
dy1 = -pos.descent * Math.cos(pos.rotate),
dx2 = pos.width * Math.cos(pos.rotate),
dy2 = pos.width * Math.sin(pos.rotate);
shape.M(pos.x + dx0, pos.y + dy0).L(pos.x + dx0 + dx2, pos.y + dy0 + dy2).M(pos.x + dx1 + dx2, pos.y + dy1 + dy2).L(pos.x + dx1, pos.y + dy1);
}
}
return shape;
};
this.drawTextInDocument = function (isClip, isMask) {
if (this.link && !isClip && !isMask) {
this.addLink();
}
if (this.get('text-decoration') === 'underline') {
this.decorate(0.05 * this._font.size, -0.075 * this._font.size, isClip, isMask);
}
if (this.get('text-decoration') === 'overline') {
this.decorate(0.05 * this._font.size, getAscent(this._font.font, this._font.size) + 0.075 * this._font.size, isClip, isMask);
}
let fill = this.getFill(isClip, isMask),
stroke = this.getStroke(isClip, isMask),
strokeWidth = this.get('stroke-width');
if (this._font.fauxBold) {
if (!stroke) {
stroke = fill;
strokeWidth = this._font.size * 0.03;
} else {
strokeWidth += this._font.size * 0.03;
}
}
let children = this.getChildren();
for (let i = 0; i < children.length; i++) {
let childElem = children[i];
switch (childElem.name) {
case 'tspan':
case 'textPath':
case 'a':
if (childElem.get('display') !== 'none') {
childElem.drawTextInDocument(isClip, isMask);
}
break;
case '#text':
case '#cdata-section':
if (this.get('visibility') === 'hidden') {
continue;
}
if (fill || stroke || isClip) {
if (fill) {
docFillColor(fill);
}
if (stroke && strokeWidth) {
docStrokeColor(stroke);
doc.lineWidth(strokeWidth).miterLimit(this.get('stroke-miterlimit')).lineJoin(this.get('stroke-linejoin')).lineCap(this.get('stroke-linecap'));
docApplyDash(this.get('stroke-dasharray'), this.get('stroke-dashoffset'));
}
docBeginText(this._font.font, this._font.size);
docSetTextMode(!!fill, !!stroke);
docWriteGlyphs(childElem._pos, this._font);
docEndText();
}
break;
}
}
if (this.get('text-decoration') === 'line-through') {
this.decorate(0.05 * this._font.size, 0.5 * (getAscent(this._font.font, this._font.size) + getDescent(this._font.font, this._font.size)), isClip, isMask);
}
};
this.decorate = function (lineWidth, linePosition, isClip, isMask) {
let fill = this.getFill(isClip, isMask),
stroke = this.getStroke(isClip, isMask);
if (fill) {
docFillColor(fill);
}
if (stroke) {
docStrokeColor(stroke);
doc.lineWidth(this.get('stroke-width')).miterLimit(this.get('stroke-miterlimit')).lineJoin(this.get('stroke-linejoin')).lineCap(this.get('stroke-linecap'));
docApplyDash(this.get('stroke-dasharray'), this.get('stroke-dashoffset'));
}
for (let j = 0, pos = this._pos; j < pos.length; j++) {
if (!pos[j].hidden && isNotEqual(pos[j].width, 0)) {
let dx0 = (linePosition + lineWidth / 2) * Math.sin(pos[j].rotate),
dy0 = -(linePosition + lineWidth / 2) * Math.cos(pos[j].rotate),
dx1 = (linePosition - lineWidth / 2) * Math.sin(pos[j].rotate),
dy1 = -(linePosition - lineWidth / 2) * Math.cos(pos[j].rotate),
dx2 = pos[j].width * Math.cos(pos[j].rotate),
dy2 = pos[j].width * Math.sin(pos[j].rotate);
new SvgShape().M(pos[j].x + dx0, pos[j].y + dy0).L(pos[j].x + dx0 + dx2, pos[j].y + dy0 + dy2).L(pos[j].x + dx1 + dx2, pos[j].y + dy1 + dy2).L(pos[j].x + dx1, pos[j].y + dy1).Z().insertInDocument();
if (fill && stroke) {
doc.fillAndStroke();
} else if (fill) {
doc.fill();
} else if (stroke) {
doc.stroke();
}
}
}
};
};
var SvgElemTextNode = function (obj, inherits) {
this.name = obj.nodeName;
this.textContent = obj.nodeValue;
};
var SvgElemTspan = function (obj, inherits) {
SvgElemTextContainer.call(this, obj, inherits);
};
var SvgElemTextPath = function (obj, inherits) {
SvgElemTextContainer.call(this, obj, inherits);
let pathObject, pathLength, temp;
if ((temp = this.attr('path')) && temp.trim() !== '') {
let pathLength = this.getLength('pathLength', this.getViewport());
this.pathObject = new SvgShape().path(temp);
this.pathLength = pathLength > 0 ? pathLength : this.pathObject.totalLength;
this.pathScale = this.pathObject.totalLength / this.pathLength;
} else if ((temp = this.getUrl('href') || this.getUrl('xlink:href')) && temp.nodeName === 'path') {
let pathElem = new SvgElemPath(temp, this);
this.pathObject = pathElem.shape.clone().transform(pathElem.get('transform'));
this.pathLength = this.chooseValue(pathElem.pathLength, this.pathObject.totalLength);
this.pathScale = this.pathObject.totalLength / this.pathLength;
}
};
var SvgElemText = function (obj, inherits) {
SvgElemTextContainer.call(this, obj, inherits);
this.allowedChildren = ['textPath', 'tspan', '#text', '#cdata-section', 'a'];
(function (textParentElem) {
let processedText = '',
remainingText = obj.textContent,
textPaths = [],
currentChunk = [],
currentAnchor,
currentDirection,
currentX = 0,
currentY = 0;
function doAnchoring() {
if (currentChunk.length) {
let last = currentChunk[currentChunk.length - 1];
let first = currentChunk[0];
let width = last.x + last.width - first.x;
let anchordx = {
'startltr': 0,
'middleltr': 0.5,
'endltr': 1,
'startrtl': 1,
'middlertl': 0.5,
'endrtl': 0
}[currentAnchor + currentDirection] * width || 0;
for (let i = 0; i < currentChunk.length; i++) {
currentChunk[i].x -= anchordx;
}
}
currentChunk = [];
}
function adjustLength(pos, length, spacingAndGlyphs) {
let firstChar = pos[0],
lastChar = pos[pos.length - 1],
startX = firstChar.x,
endX = lastChar.x + lastChar.width;
if (spacingAndGlyphs) {
let textScale = length / (endX - startX);
if (textScale > 0 && textScale < Infinity) {
for (let j = 0; j < pos.length; j++) {
pos[j].continuous = false;
pos[j].x = startX + textScale * (pos[j].x - startX);
pos[j].scale *= textScale;
pos[j].width *= textScale;
}
}
} else {
if (pos.length >= 2) {
let spaceDiff = (length - (endX - startX)) / (pos.length - 1);
for (let j = 0; j < pos.length; j++) {
pos[j].continuous = false;
pos[j].x += j * spaceDiff;
}
}
}
currentX += length - (endX - startX);
}
function recursive(currentElem, parentElem) {
currentElem._x = combineArrays(currentElem.getLengthList('x', currentElem.getVWidth()), parentElem ? parentElem._x.slice(parentElem._pos.length) : []);
currentElem._y = combineArrays(currentElem.getLengthList('y', currentElem.getVHeight()), parentElem ? parentElem._y.slice(parentElem._pos.length) : []);
currentElem._dx = combineArrays(currentElem.getLengthList('dx', currentElem.getVWidth()), parentElem ? parentElem._dx.slice(parentElem._pos.length) : []);
currentElem._dy = combineArrays(currentElem.getLengthList('dy', currentElem.getVHeight()), parentElem ? parentElem._dy.slice(parentElem._pos.length) : []);
currentElem._rot = combineArrays(currentElem.getNumberList('rotate'), parentElem ? parentElem._rot.slice(parentElem._pos.length) : []);
currentElem._defRot = currentElem.chooseValue(currentElem._rot[currentElem._rot.length - 1], parentElem && parentElem._defRot, 0);
if (currentElem.name === 'textPath') {
currentElem._y = [];
}
let fontOptions = {
fauxItalic: false,
fauxBold: false
},
fontNameorLink = fontCallback(currentElem.get('font-family'), currentElem.get('font-weight') === 'bold', currentElem.get('font-style') === 'italic', fontOptions);
try {
doc.font(fontNameorLink);
} catch (e) {
warningCallback('SVGElemText: failed to open font "' + fontNameorLink + '" in PDFKit: ' + e.message);
}
currentElem._pos = [];
currentElem._index = 0;
currentElem._font = {
font: doc._font,
size: currentElem.get('font-size'),
fauxItalic: fontOptions.fauxItalic,
fauxBold: fontOptions.fauxBold
};
let textLength = currentElem.getLength('textLength', currentElem.getVWidth(), undefined),
spacingAndGlyphs = currentElem.attr('lengthAdjust') === 'spacingAndGlyphs',
wordSpacing = currentElem.get('word-spacing'),
letterSpacing = currentElem.get('letter-spacing'),
textAnchor = currentElem.get('text-anchor'),
textDirection = currentElem.get('direction'),
// `alignment-baseline` and `baseline-shift` have no effect on
// `<text>` elements according to the SVG spec. So, detect when
// we're styling a `<text>` element and ignore
// `alignment-baseline` (only factoring in `dominant-baseline`)
// and `baseline-shift` (which can only have the default value of
// `baseline`).
//
// Note that Chrome (as of v99) incorrectly factors in
// `alignment-baseline` on `<text>` elements, while Firefox
// correctly follows the spec and ignores it. This means that our
// output will differ from Chrome's in these cases, but conform to
// SVG specification.
isTextElem = currentElem.name === 'text',
baselineAttr = isTextElem ? currentElem.get('dominant-baseline') : currentElem.get('alignment-baseline') || currentElem.get('dominant-baseline'),
baselineShiftAttr = isTextElem ? 'baseline' : currentElem.get('baseline-shift'),
baseline = getBaseline(currentElem._font.font, currentElem._font.size, baselineAttr, baselineShiftAttr);
if (currentElem.name === 'textPath') {
doAnchoring();
currentX = currentY = 0;
}
let children = currentElem.getChildren();
for (let i = 0; i < children.length; i++) {
let childElem = children[i];
switch (childElem.name) {
case 'tspan':
case 'textPath':
case 'a':
recursive(childElem, currentElem);
break;
case '#text':
case '#cdata-section':
let rawText = childElem.textContent,
renderedText = rawText,
words;
childElem._font = currentElem._font;
childElem._pos = [];
remainingText = remainingText.substring(rawText.length);
if (currentElem.get('xml:space') === 'preserve') {
renderedText = renderedText.replace(/[\s]/g, ' ');
} else {
renderedText = renderedText.replace(/[\s]+/g, ' ');
if (processedText.match(/[\s]$|^$/)) {
renderedText = renderedText.replace(/^[\s]/, '');
}
if (remainingText.match(/^[\s]*$/)) {
renderedText = renderedText.replace(/[\s]$/, '');
}
}
processedText += rawText;
if (wordSpacing === 0) {
words = [renderedText];
} else {
words = renderedText.split(/(\s)/);
}
for (let w = 0; w < words.length; w++) {
let pos = getTextPos(currentElem._font.font, currentElem._font.size, words[w]);
for (let j = 0; j < pos.length; j++) {
let index = currentElem._index,
xAttr = currentElem._x[index],
yAttr = currentElem._y[index],
dxAttr = currentElem._dx[index],
dyAttr = currentElem._dy[index],
rotAttr = currentElem._rot[index],
continuous = !(w === 0 && j === 0);
if (letterSpacing !== 0) {
continuous = false;
}
if (wordSpacing !== 0) {
continuous = false;
}
if (xAttr !== undefined) {
continuous = false;
doAnchoring();
currentX = xAttr;
}
if (yAttr !== undefined) {
continuous = false;
doAnchoring();
currentY = yAttr;
}
if (dxAttr !== undefined) {
continuous = false;
currentX += dxAttr;
}
if (dyAttr !== undefined) {
continuous = false;
currentY += dyAttr;
}
if (rotAttr !== undefined || currentElem._defRot !== 0) {
continuous = false;
}
let position = {
glyph: pos[j].glyph,
rotate: Math.PI / 180 * currentElem.chooseValue(rotAttr, currentElem._defRot),
x: currentX + pos[j].xOffset,
kern: pos[j].kern,
y: currentY + baseline + pos[j].yOffset,
width: pos[j].width,
ascent: getAscent(currentElem._font.font, currentElem._font.size),
descent: getDescent(currentElem._font.font, currentElem._font.size),
scale: 1,
hidden: false,
continuous: continuous
};
currentChunk.push(position);
childElem._pos.push(position);
currentElem._pos.push(position);
currentElem._index += pos[j].unicode.length;
if (currentChunk.length === 1) {
currentAnchor = textAnchor;
currentDirection = textDirection;
}
currentX += pos[j].xAdvance + letterSpacing;
currentY += pos[j].yAdvance;
}
if (words[w] === ' ') {
currentX += wordSpacing;
}
}
break;
default:
remainingText = remainingText.substring(childElem.textContent.length);
}
}
if (textLength && currentElem._pos.length) {
adjustLength(currentElem._pos, textLength, spacingAndGlyphs);
}
if (currentElem.name === 'textPath' || currentElem.name === 'text') {
doAnchoring();
}
if (currentElem.name === 'textPath') {
textPaths.push(currentElem);
let pathObject = currentElem.pathObject;
if (pathObject) {
currentX = pathObject.endPoint[0];
currentY = pathObject.endPoint[1];
}
}
if (parentElem) {
parentElem._pos = parentElem._pos.concat(currentElem._pos);
parentElem._index += currentElem._index;
}
}
function textOnPath(currentElem) {
let pathObject = currentElem.pathObject,
pathLength = currentElem.pathLength,
pathScale = currentElem.pathScale;
if (pathObject) {
let textOffset = currentElem.getLength('startOffset', pathLength, 0);
for (let j = 0; j < currentElem._pos.length; j++) {
let charMidX = textOffset + currentElem._pos[j].x + 0.5 * currentElem._pos[j].width;
if (charMidX > pathLength || charMidX < 0) {
currentElem._pos[j].hidden = true;
} else {
let pointOnPath = pathObject.getPointAtLength(charMidX * pathScale);
if (isNotEqual(pathScale, 1)) {
currentElem._pos[j].scale *= pathScale;
currentElem._pos[j].width *= pathScale;
}
currentElem._pos[j].x = pointOnPath[0] - 0.5 * currentElem._pos[j].width * Math.cos(pointOnPath[2]) - currentElem._pos[j].y * Math.sin(pointOnPath[2]);
currentElem._pos[j].y = pointOnPath[1] - 0.5 * currentElem._pos[j].width * Math.sin(pointOnPath[2]) + currentElem._pos[j].y * Math.cos(pointOnPath[2]);
currentElem._pos[j].rotate = pointOnPath[2] + currentElem._pos[j].rotate;
currentElem._pos[j].continuous = false;
}
}
} else {
for (let j = 0; j < currentElem._pos.length; j++) {
currentElem._pos[j].hidden = true;
}
}
}
recursive(textParentElem, null);
for (let i = 0; i < textPaths.length; i++) {
textOnPath(textPaths[i]);
}
})(this);
this.getTransformation = function () {
return this.get('transform');
};
this.drawInDocument = function (isClip, isMask) {
doc.save();
this.transform();
this.clip();
let masked = this.mask(),
group;
if (masked) {
group = docBeginGroup(getPageBBox());
}
this.drawTextInDocument(isClip, isMask);
if (group) {
docEndGroup(group);
docInsertGroup(group);
}
doc.restore();
};
};
options = options || {};
var pxToPt = options.assumePt ? 1 : 72 / 96,
// 1px = 72/96pt, but only if assumePt is false
viewportWidth = (options.width || doc.page.width) / pxToPt,
viewportHeight = (options.height || doc.page.height) / pxToPt,
preserveAspectRatio = options.preserveAspectRatio || null,
// default to null so that the attr can override if not passed
useCSS = options.useCSS && typeof SVGElement !== 'undefined' && svg instanceof SVGElement && typeof getComputedStyle === 'function',
warningCallback = options.warningCallback,
fontCallback = options.fontCallback,
imageCallback = options.imageCallback,
colorCallback = options.colorCallback,
documentCallback = options.documentCallback,
precision = Math.ceil(Math.max(1, options.precision)) || 3,
groupStack = [],
documentCache = {},
links = [],
styleRules = [],
useExpansionElements = 0;
const MAX_USE_EXPANSION_ELEMENTS = 20000,
MAX_USE_DEPTH = 64;
if (typeof warningCallback !== 'function') {
warningCallback = function (str) {
if (typeof console !== undefined && typeof console.warn === 'function') {
console.warn(str);
}
};
}
if (typeof fontCallback !== 'function') {
fontCallback = function (family, bold, italic, fontOptions) {
// Check if the font is already registered in the document
if (bold && italic) {
if (doc._registeredFonts.hasOwnProperty(family + '-BoldItalic')) {
return family + '-BoldItalic';
} else if (doc._registeredFonts.hasOwnProperty(family + '-Italic')) {
fontOptions.fauxBold = true;
return family + '-Italic';
} else if (doc._registeredFonts.hasOwnProperty(family + '-Bold')) {
fontOptions.fauxItalic = true;
return family + '-Bold';
} else if (doc._registeredFonts.hasOwnProperty(family)) {
fontOptions.fauxBold = true;
fontOptions.fauxItalic = true;
return family;
}
}
if (bold && !italic) {
if (doc._registeredFonts.hasOwnProperty(family + '-Bold')) {
return family + '-Bold';
} else if (doc._registeredFonts.hasOwnProperty(family)) {
fontOptions.fauxBold = true;
return family;
}
}
if (!bold && italic) {
if (doc._registeredFonts.hasOwnProperty(family + '-Italic')) {
return family + '-Italic';
} else if (doc._registeredFonts.hasOwnProperty(family)) {
fontOptions.fauxItalic = true;
return family;
}
}
if (!bold && !italic) {
if (doc._registeredFonts.hasOwnProperty(family)) {
return family;
}
}
// Use standard fonts as fallback
if (family.match(/(?:^|,)\s*serif\s*$/)) {
if (bold && italic) {
return 'Times-BoldItalic';
}
if (bold && !italic) {
return 'Times-Bold';
}
if (!bold && italic) {
return 'Times-Italic';
}
if (!bold && !italic) {
return 'Times-Roman';
}
} else if (family.match(/(?:^|,)\s*monospace\s*$/)) {
if (bold && italic) {
return 'Courier-BoldOblique';
}
if (bold && !italic) {
return 'Courier-Bold';
}
if (!bold && italic) {
return 'Courier-Oblique';
}
if (!bold && !italic) {
return 'Courier';
}
} else if (family.match(/(?:^|,)\s*sans-serif\s*$/) || true) {
if (bold && italic) {
return 'Helvetica-BoldOblique';
}
if (bold && !italic) {
return 'Helvetica-Bold';
}
if (!bold && italic) {
return 'Helvetica-Oblique';
}
if (!bold && !italic) {
return 'Helvetica';
}
}
};
}
if (typeof imageCallback !== 'function') {
imageCallback = function (link) {
return link.replace(/\s+/g, '');
};
}
if (typeof colorCallback !== 'function') {
colorCallback = null;
} else {
for (let color in DefaultColors) {
let newColor = colorCallback(DefaultColors[color]);
DefaultColors[color][0] = newColor[0];
DefaultColors[color][1] = newColor[1];
}
}
if (typeof documentCallback !== 'function') {
documentCallback = null;
}
if (typeof svg === 'string') {
svg = parseXml(svg);
}
if (svg) {
let styles = svg.getElementsByTagName('style');
for (let i = 0; i < styles.length; i++) {
styleRules = styleRules.concat(parseStyleSheet(styles[i].textContent));
}
let elem = createSVGElement(svg, null);
if (typeof elem.drawInDocument === 'function') {
if (options.useCSS && !useCSS) {
warningCallback('SVGtoPDF: useCSS option can only be used for SVG *elements* in compatible browsers');
}
let savedFillColor = doc._fillColor;
doc.save().translate(x || 0, y || 0).scale(pxToPt);
elem.drawInDocument();
for (let i = 0; i < links.length; i++) {
doc.page.annotations.push(links[i]);
}
doc.restore();
doc._fillColor = savedFillColor;
} else {
warningCallback('SVGtoPDF: this element can\'t be rendered directly: ' + svg.nodeName);
}
} else {
warningCallback('SVGtoPDF: the input does not look like a valid SVG');
}
};
if (typeof module !== 'undefined' && module && typeof module.exports !== 'undefined') {
module.exports = SVGtoPDF;
}